ortools.constraint_solver.pywrapcp

   1# This file was automatically generated by SWIG (https://www.swig.org).
   2# Version 4.1.1
   3#
   4# Do not make changes to this file unless you know what you are doing - modify
   5# the SWIG interface file instead.
   6
   7from sys import version_info as _swig_python_version_info
   8# Import the low-level C/C++ module
   9if __package__ or "." in __name__:
  10    from . import _pywrapcp
  11else:
  12    import _pywrapcp
  13
  14try:
  15    import builtins as __builtin__
  16except ImportError:
  17    import __builtin__
  18
  19def _swig_repr(self):
  20    try:
  21        strthis = "proxy of " + self.this.__repr__()
  22    except __builtin__.Exception:
  23        strthis = ""
  24    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
  25
  26
  27def _swig_setattr_nondynamic_instance_variable(set):
  28    def set_instance_attr(self, name, value):
  29        if name == "this":
  30            set(self, name, value)
  31        elif name == "thisown":
  32            self.this.own(value)
  33        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
  34            set(self, name, value)
  35        else:
  36            raise AttributeError("You cannot add instance attributes to %s" % self)
  37    return set_instance_attr
  38
  39
  40def _swig_setattr_nondynamic_class_variable(set):
  41    def set_class_attr(cls, name, value):
  42        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
  43            set(cls, name, value)
  44        else:
  45            raise AttributeError("You cannot add class attributes to %s" % cls)
  46    return set_class_attr
  47
  48
  49def _swig_add_metaclass(metaclass):
  50    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
  51    def wrapper(cls):
  52        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
  53    return wrapper
  54
  55
  56class _SwigNonDynamicMeta(type):
  57    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
  58    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
  59
  60
  61import weakref
  62
  63class DefaultPhaseParameters(object):
  64    r"""
  65    This struct holds all parameters for the default search.
  66    DefaultPhaseParameters is only used by Solver::MakeDefaultPhase methods.
  67    Note this is for advanced users only.
  68    """
  69
  70    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
  71    __repr__ = _swig_repr
  72    CHOOSE_MAX_SUM_IMPACT = _pywrapcp.DefaultPhaseParameters_CHOOSE_MAX_SUM_IMPACT
  73    CHOOSE_MAX_AVERAGE_IMPACT = _pywrapcp.DefaultPhaseParameters_CHOOSE_MAX_AVERAGE_IMPACT
  74    CHOOSE_MAX_VALUE_IMPACT = _pywrapcp.DefaultPhaseParameters_CHOOSE_MAX_VALUE_IMPACT
  75    SELECT_MIN_IMPACT = _pywrapcp.DefaultPhaseParameters_SELECT_MIN_IMPACT
  76    SELECT_MAX_IMPACT = _pywrapcp.DefaultPhaseParameters_SELECT_MAX_IMPACT
  77    NONE = _pywrapcp.DefaultPhaseParameters_NONE
  78    NORMAL = _pywrapcp.DefaultPhaseParameters_NORMAL
  79    VERBOSE = _pywrapcp.DefaultPhaseParameters_VERBOSE
  80    var_selection_schema = property(_pywrapcp.DefaultPhaseParameters_var_selection_schema_get, _pywrapcp.DefaultPhaseParameters_var_selection_schema_set, doc=r"""
  81    This parameter describes how the next variable to instantiate
  82    will be chosen.
  83    """)
  84    value_selection_schema = property(_pywrapcp.DefaultPhaseParameters_value_selection_schema_get, _pywrapcp.DefaultPhaseParameters_value_selection_schema_set, doc=r""" This parameter describes which value to select for a given var.""")
  85    initialization_splits = property(_pywrapcp.DefaultPhaseParameters_initialization_splits_get, _pywrapcp.DefaultPhaseParameters_initialization_splits_set, doc=r"""
  86    Maximum number of intervals that the initialization of impacts will scan
  87    per variable.
  88    """)
  89    run_all_heuristics = property(_pywrapcp.DefaultPhaseParameters_run_all_heuristics_get, _pywrapcp.DefaultPhaseParameters_run_all_heuristics_set, doc=r"""
  90    The default phase will run heuristics periodically. This parameter
  91    indicates if we should run all heuristics, or a randomly selected
  92    one.
  93    """)
  94    heuristic_period = property(_pywrapcp.DefaultPhaseParameters_heuristic_period_get, _pywrapcp.DefaultPhaseParameters_heuristic_period_set, doc=r"""
  95    The distance in nodes between each run of the heuristics. A
  96    negative or null value will mean that we will not run heuristics
  97    at all.
  98    """)
  99    heuristic_num_failures_limit = property(_pywrapcp.DefaultPhaseParameters_heuristic_num_failures_limit_get, _pywrapcp.DefaultPhaseParameters_heuristic_num_failures_limit_set, doc=r""" The failure limit for each heuristic that we run.""")
 100    persistent_impact = property(_pywrapcp.DefaultPhaseParameters_persistent_impact_get, _pywrapcp.DefaultPhaseParameters_persistent_impact_set, doc=r"""
 101    Whether to keep the impact from the first search for other searches,
 102    or to recompute the impact for each new search.
 103    """)
 104    random_seed = property(_pywrapcp.DefaultPhaseParameters_random_seed_get, _pywrapcp.DefaultPhaseParameters_random_seed_set, doc=r""" Seed used to initialize the random part in some heuristics.""")
 105    display_level = property(_pywrapcp.DefaultPhaseParameters_display_level_get, _pywrapcp.DefaultPhaseParameters_display_level_set, doc=r"""
 106    This represents the amount of information displayed by the default search.
 107    NONE means no display, VERBOSE means extra information.
 108    """)
 109    decision_builder = property(_pywrapcp.DefaultPhaseParameters_decision_builder_get, _pywrapcp.DefaultPhaseParameters_decision_builder_set, doc=r""" When defined, this overrides the default impact based decision builder.""")
 110
 111    def __init__(self):
 112        _pywrapcp.DefaultPhaseParameters_swiginit(self, _pywrapcp.new_DefaultPhaseParameters())
 113    __swig_destroy__ = _pywrapcp.delete_DefaultPhaseParameters
 114
 115# Register DefaultPhaseParameters in _pywrapcp:
 116_pywrapcp.DefaultPhaseParameters_swigregister(DefaultPhaseParameters)
 117class Solver(object):
 118    r"""
 119    Solver Class
 120
 121    A solver represents the main computation engine. It implements the entire
 122    range of Constraint Programming protocols:
 123      - Reversibility
 124      - Propagation
 125      - Search
 126
 127    Usually, Constraint Programming code consists of
 128      - the creation of the Solver,
 129      - the creation of the decision variables of the model,
 130      - the creation of the constraints of the model and their addition to the
 131        solver() through the AddConstraint() method,
 132      - the creation of the main DecisionBuilder class,
 133      - the launch of the solve() method with the decision builder.
 134
 135    For the time being, Solver is neither MT_SAFE nor MT_HOT.
 136    """
 137
 138    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
 139    __repr__ = _swig_repr
 140    INT_VAR_DEFAULT = _pywrapcp.Solver_INT_VAR_DEFAULT
 141    r""" The default behavior is CHOOSE_FIRST_UNBOUND."""
 142    INT_VAR_SIMPLE = _pywrapcp.Solver_INT_VAR_SIMPLE
 143    r""" The simple selection is CHOOSE_FIRST_UNBOUND."""
 144    CHOOSE_FIRST_UNBOUND = _pywrapcp.Solver_CHOOSE_FIRST_UNBOUND
 145    r"""
 146    Select the first unbound variable.
 147    Variables are considered in the order of the vector of IntVars used
 148    to create the selector.
 149    """
 150    CHOOSE_RANDOM = _pywrapcp.Solver_CHOOSE_RANDOM
 151    r""" Randomly select one of the remaining unbound variables."""
 152    CHOOSE_MIN_SIZE_LOWEST_MIN = _pywrapcp.Solver_CHOOSE_MIN_SIZE_LOWEST_MIN
 153    r"""
 154    Among unbound variables, select the variable with the smallest size,
 155    i.e., the smallest number of possible values.
 156    In case of a tie, the selected variables is the one with the lowest min
 157    value.
 158    In case of a tie, the first one is selected, first being defined by the
 159    order in the vector of IntVars used to create the selector.
 160    """
 161    CHOOSE_MIN_SIZE_HIGHEST_MIN = _pywrapcp.Solver_CHOOSE_MIN_SIZE_HIGHEST_MIN
 162    r"""
 163    Among unbound variables, select the variable with the smallest size,
 164    i.e., the smallest number of possible values.
 165    In case of a tie, the selected variable is the one with the highest min
 166    value.
 167    In case of a tie, the first one is selected, first being defined by the
 168    order in the vector of IntVars used to create the selector.
 169    """
 170    CHOOSE_MIN_SIZE_LOWEST_MAX = _pywrapcp.Solver_CHOOSE_MIN_SIZE_LOWEST_MAX
 171    r"""
 172    Among unbound variables, select the variable with the smallest size,
 173    i.e., the smallest number of possible values.
 174    In case of a tie, the selected variables is the one with the lowest max
 175    value.
 176    In case of a tie, the first one is selected, first being defined by the
 177    order in the vector of IntVars used to create the selector.
 178    """
 179    CHOOSE_MIN_SIZE_HIGHEST_MAX = _pywrapcp.Solver_CHOOSE_MIN_SIZE_HIGHEST_MAX
 180    r"""
 181    Among unbound variables, select the variable with the smallest size,
 182    i.e., the smallest number of possible values.
 183    In case of a tie, the selected variable is the one with the highest max
 184    value.
 185    In case of a tie, the first one is selected, first being defined by the
 186    order in the vector of IntVars used to create the selector.
 187    """
 188    CHOOSE_LOWEST_MIN = _pywrapcp.Solver_CHOOSE_LOWEST_MIN
 189    r"""
 190    Among unbound variables, select the variable with the smallest minimal
 191    value.
 192    In case of a tie, the first one is selected, "first" defined by the
 193    order in the vector of IntVars used to create the selector.
 194    """
 195    CHOOSE_HIGHEST_MAX = _pywrapcp.Solver_CHOOSE_HIGHEST_MAX
 196    r"""
 197    Among unbound variables, select the variable with the highest maximal
 198    value.
 199    In case of a tie, the first one is selected, first being defined by the
 200    order in the vector of IntVars used to create the selector.
 201    """
 202    CHOOSE_MIN_SIZE = _pywrapcp.Solver_CHOOSE_MIN_SIZE
 203    r"""
 204    Among unbound variables, select the variable with the smallest size.
 205    In case of a tie, the first one is selected, first being defined by the
 206    order in the vector of IntVars used to create the selector.
 207    """
 208    CHOOSE_MAX_SIZE = _pywrapcp.Solver_CHOOSE_MAX_SIZE
 209    r"""
 210    Among unbound variables, select the variable with the highest size.
 211    In case of a tie, the first one is selected, first being defined by the
 212    order in the vector of IntVars used to create the selector.
 213    """
 214    CHOOSE_MAX_REGRET_ON_MIN = _pywrapcp.Solver_CHOOSE_MAX_REGRET_ON_MIN
 215    r"""
 216    Among unbound variables, select the variable with the largest
 217    gap between the first and the second values of the domain.
 218    """
 219    CHOOSE_PATH = _pywrapcp.Solver_CHOOSE_PATH
 220    r"""
 221    Selects the next unbound variable on a path, the path being defined by
 222    the variables: var[i] corresponds to the index of the next of i.
 223    """
 224    INT_VALUE_DEFAULT = _pywrapcp.Solver_INT_VALUE_DEFAULT
 225    r""" The default behavior is ASSIGN_MIN_VALUE."""
 226    INT_VALUE_SIMPLE = _pywrapcp.Solver_INT_VALUE_SIMPLE
 227    r""" The simple selection is ASSIGN_MIN_VALUE."""
 228    ASSIGN_MIN_VALUE = _pywrapcp.Solver_ASSIGN_MIN_VALUE
 229    r""" Selects the min value of the selected variable."""
 230    ASSIGN_MAX_VALUE = _pywrapcp.Solver_ASSIGN_MAX_VALUE
 231    r""" Selects the max value of the selected variable."""
 232    ASSIGN_RANDOM_VALUE = _pywrapcp.Solver_ASSIGN_RANDOM_VALUE
 233    r""" Selects randomly one of the possible values of the selected variable."""
 234    ASSIGN_CENTER_VALUE = _pywrapcp.Solver_ASSIGN_CENTER_VALUE
 235    r"""
 236    Selects the first possible value which is the closest to the center
 237    of the domain of the selected variable.
 238    The center is defined as (min + max) / 2.
 239    """
 240    SPLIT_LOWER_HALF = _pywrapcp.Solver_SPLIT_LOWER_HALF
 241    r"""
 242    Split the domain in two around the center, and choose the lower
 243    part first.
 244    """
 245    SPLIT_UPPER_HALF = _pywrapcp.Solver_SPLIT_UPPER_HALF
 246    r"""
 247    Split the domain in two around the center, and choose the lower
 248    part first.
 249    """
 250    SEQUENCE_DEFAULT = _pywrapcp.Solver_SEQUENCE_DEFAULT
 251    SEQUENCE_SIMPLE = _pywrapcp.Solver_SEQUENCE_SIMPLE
 252    CHOOSE_MIN_SLACK_RANK_FORWARD = _pywrapcp.Solver_CHOOSE_MIN_SLACK_RANK_FORWARD
 253    CHOOSE_RANDOM_RANK_FORWARD = _pywrapcp.Solver_CHOOSE_RANDOM_RANK_FORWARD
 254    INTERVAL_DEFAULT = _pywrapcp.Solver_INTERVAL_DEFAULT
 255    r""" The default is INTERVAL_SET_TIMES_FORWARD."""
 256    INTERVAL_SIMPLE = _pywrapcp.Solver_INTERVAL_SIMPLE
 257    r""" The simple is INTERVAL_SET_TIMES_FORWARD."""
 258    INTERVAL_SET_TIMES_FORWARD = _pywrapcp.Solver_INTERVAL_SET_TIMES_FORWARD
 259    r"""
 260    Selects the variable with the lowest starting time of all variables,
 261    and fixes its starting time to this lowest value.
 262    """
 263    INTERVAL_SET_TIMES_BACKWARD = _pywrapcp.Solver_INTERVAL_SET_TIMES_BACKWARD
 264    r"""
 265    Selects the variable with the highest ending time of all variables,
 266    and fixes the ending time to this highest values.
 267    """
 268    TWOOPT = _pywrapcp.Solver_TWOOPT
 269    r"""
 270    Operator which reverses a sub-chain of a path. It is called TwoOpt
 271    because it breaks two arcs on the path; resulting paths are called
 272    two-optimal.
 273    Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5
 274    (where (1, 5) are first and last nodes of the path and can therefore not
 275    be moved):
 276      1 -> [3 -> 2] -> 4  -> 5
 277      1 -> [4 -> 3  -> 2] -> 5
 278      1 ->  2 -> [4 -> 3] -> 5
 279    """
 280    OROPT = _pywrapcp.Solver_OROPT
 281    r"""
 282    Relocate: OROPT and RELOCATE.
 283    Operator which moves a sub-chain of a path to another position; the
 284    specified chain length is the fixed length of the chains being moved.
 285    When this length is 1, the operator simply moves a node to another
 286    position.
 287    Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5, for a chain
 288    length of 2 (where (1, 5) are first and last nodes of the path and can
 289    therefore not be moved):
 290      1 ->  4 -> [2 -> 3] -> 5
 291      1 -> [3 -> 4] -> 2  -> 5
 292
 293    Using Relocate with chain lengths of 1, 2 and 3 together is equivalent
 294    to the OrOpt operator on a path. The OrOpt operator is a limited
 295     version of 3Opt (breaks 3 arcs on a path).
 296    """
 297    RELOCATE = _pywrapcp.Solver_RELOCATE
 298    r""" Relocate neighborhood with length of 1 (see OROPT comment)."""
 299    EXCHANGE = _pywrapcp.Solver_EXCHANGE
 300    r"""
 301    Operator which exchanges the positions of two nodes.
 302    Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5
 303    (where (1, 5) are first and last nodes of the path and can therefore not
 304    be moved):
 305      1 -> [3] -> [2] ->  4  -> 5
 306      1 -> [4] ->  3  -> [2] -> 5
 307      1 ->  2  -> [4] -> [3] -> 5
 308    """
 309    CROSS = _pywrapcp.Solver_CROSS
 310    r"""
 311    Operator which cross exchanges the starting chains of 2 paths, including
 312    exchanging the whole paths.
 313    First and last nodes are not moved.
 314    Possible neighbors for the paths 1 -> 2 -> 3 -> 4 -> 5 and 6 -> 7 -> 8
 315    (where (1, 5) and (6, 8) are first and last nodes of the paths and can
 316    therefore not be moved):
 317      1 -> [7] -> 3 -> 4 -> 5  6 -> [2] -> 8
 318      1 -> [7] -> 4 -> 5       6 -> [2 -> 3] -> 8
 319      1 -> [7] -> 5            6 -> [2 -> 3 -> 4] -> 8
 320    """
 321    MAKEACTIVE = _pywrapcp.Solver_MAKEACTIVE
 322    r"""
 323    Operator which inserts an inactive node into a path.
 324    Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive
 325    (where 1 and 4 are first and last nodes of the path) are:
 326      1 -> [5] ->  2  ->  3  -> 4
 327      1 ->  2  -> [5] ->  3  -> 4
 328      1 ->  2  ->  3  -> [5] -> 4
 329    """
 330    MAKEINACTIVE = _pywrapcp.Solver_MAKEINACTIVE
 331    r"""
 332    Operator which makes path nodes inactive.
 333    Possible neighbors for the path 1 -> 2 -> 3 -> 4 (where 1 and 4 are
 334    first and last nodes of the path) are:
 335      1 -> 3 -> 4 with 2 inactive
 336      1 -> 2 -> 4 with 3 inactive
 337    """
 338    MAKECHAININACTIVE = _pywrapcp.Solver_MAKECHAININACTIVE
 339    r"""
 340    Operator which makes a "chain" of path nodes inactive.
 341    Possible neighbors for the path 1 -> 2 -> 3 -> 4 (where 1 and 4 are
 342    first and last nodes of the path) are:
 343      1 -> 3 -> 4 with 2 inactive
 344      1 -> 2 -> 4 with 3 inactive
 345      1 -> 4 with 2 and 3 inactive
 346    """
 347    SWAPACTIVE = _pywrapcp.Solver_SWAPACTIVE
 348    r"""
 349    Operator which replaces an active node by an inactive one.
 350    Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive
 351    (where 1 and 4 are first and last nodes of the path) are:
 352      1 -> [5] ->  3  -> 4 with 2 inactive
 353      1 ->  2  -> [5] -> 4 with 3 inactive
 354    """
 355    EXTENDEDSWAPACTIVE = _pywrapcp.Solver_EXTENDEDSWAPACTIVE
 356    r"""
 357    Operator which makes an inactive node active and an active one inactive.
 358    It is similar to SwapActiveOperator except that it tries to insert the
 359    inactive node in all possible positions instead of just the position of
 360    the node made inactive.
 361    Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive
 362    (where 1 and 4 are first and last nodes of the path) are:
 363      1 -> [5] ->  3  -> 4 with 2 inactive
 364      1 ->  3  -> [5] -> 4 with 2 inactive
 365      1 -> [5] ->  2  -> 4 with 3 inactive
 366      1 ->  2  -> [5] -> 4 with 3 inactive
 367    """
 368    PATHLNS = _pywrapcp.Solver_PATHLNS
 369    r"""
 370    Operator which relaxes two sub-chains of three consecutive arcs each.
 371    Each sub-chain is defined by a start node and the next three arcs. Those
 372    six arcs are relaxed to build a new neighbor.
 373    PATHLNS explores all possible pairs of starting nodes and so defines
 374    n^2 neighbors, n being the number of nodes.
 375    Note that the two sub-chains can be part of the same path; they even may
 376    overlap.
 377    """
 378    FULLPATHLNS = _pywrapcp.Solver_FULLPATHLNS
 379    r"""
 380    Operator which relaxes one entire path and all inactive nodes, thus
 381    defining num_paths neighbors.
 382    """
 383    UNACTIVELNS = _pywrapcp.Solver_UNACTIVELNS
 384    r"""
 385    Operator which relaxes all inactive nodes and one sub-chain of six
 386    consecutive arcs. That way the path can be improved by inserting
 387    inactive nodes or swapping arcs.
 388    """
 389    INCREMENT = _pywrapcp.Solver_INCREMENT
 390    r"""
 391    Operator which defines one neighbor per variable. Each neighbor tries to
 392    increment by one the value of the corresponding variable. When a new
 393    solution is found the neighborhood is rebuilt from scratch, i.e., tries
 394    to increment values in the variable order.
 395    Consider for instance variables x and y. x is incremented one by one to
 396    its max, and when it is not possible to increment x anymore, y is
 397    incremented once. If this is a solution, then next neighbor tries to
 398    increment x.
 399    """
 400    DECREMENT = _pywrapcp.Solver_DECREMENT
 401    r"""
 402    Operator which defines a neighborhood to decrement values.
 403    The behavior is the same as INCREMENT, except values are decremented
 404    instead of incremented.
 405    """
 406    SIMPLELNS = _pywrapcp.Solver_SIMPLELNS
 407    r"""
 408    Operator which defines one neighbor per variable. Each neighbor relaxes
 409    one variable.
 410    When a new solution is found the neighborhood is rebuilt from scratch.
 411    Consider for instance variables x and y. First x is relaxed and the
 412    solver is looking for the best possible solution (with only x relaxed).
 413    Then y is relaxed, and the solver is looking for a new solution.
 414    If a new solution is found, then the next variable to be relaxed is x.
 415    """
 416    GE = _pywrapcp.Solver_GE
 417    r""" Move is accepted when the current objective value >= objective.Min."""
 418    LE = _pywrapcp.Solver_LE
 419    r""" Move is accepted when the current objective value <= objective.Max."""
 420    EQ = _pywrapcp.Solver_EQ
 421    r"""
 422    Move is accepted when the current objective value is in the interval
 423    objective.Min .. objective.Max.
 424    """
 425    DELAYED_PRIORITY = _pywrapcp.Solver_DELAYED_PRIORITY
 426    r"""
 427    DELAYED_PRIORITY is the lowest priority: Demons will be processed after
 428    VAR_PRIORITY and NORMAL_PRIORITY demons.
 429    """
 430    VAR_PRIORITY = _pywrapcp.Solver_VAR_PRIORITY
 431    r""" VAR_PRIORITY is between DELAYED_PRIORITY and NORMAL_PRIORITY."""
 432    NORMAL_PRIORITY = _pywrapcp.Solver_NORMAL_PRIORITY
 433    r""" NORMAL_PRIORITY is the highest priority: Demons will be processed first."""
 434
 435    def __init__(self, *args):
 436        _pywrapcp.Solver_swiginit(self, _pywrapcp.new_Solver(*args))
 437
 438        self.__python_constraints = []
 439
 440
 441
 442    __swig_destroy__ = _pywrapcp.delete_Solver
 443
 444    def Parameters(self):
 445        r""" Stored Parameters."""
 446        return _pywrapcp.Solver_Parameters(self)
 447
 448    @staticmethod
 449    def DefaultSolverParameters():
 450        r""" Create a ConstraintSolverParameters proto with all the default values."""
 451        return _pywrapcp.Solver_DefaultSolverParameters()
 452
 453    def AddConstraint(self, c):
 454        r"""
 455        Adds the constraint 'c' to the model.
 456
 457        After calling this method, and until there is a backtrack that undoes the
 458        addition, any assignment of variables to values must satisfy the given
 459        constraint in order to be considered feasible. There are two fairly
 460        different use cases:
 461
 462        - the most common use case is modeling: the given constraint is really
 463        part of the problem that the user is trying to solve. In this use case,
 464        AddConstraint is called outside of search (i.e., with state() ==
 465        OUTSIDE_SEARCH). Most users should only use AddConstraint in this
 466        way. In this case, the constraint will belong to the model forever: it
 467        cannot be removed by backtracking.
 468
 469        - a rarer use case is that 'c' is not a real constraint of the model. It
 470        may be a constraint generated by a branching decision (a constraint whose
 471        goal is to restrict the search space), a symmetry breaking constraint (a
 472        constraint that does restrict the search space, but in a way that cannot
 473        have an impact on the quality of the solutions in the subtree), or an
 474        inferred constraint that, while having no semantic value to the model (it
 475        does not restrict the set of solutions), is worth having because we
 476        believe it may strengthen the propagation. In these cases, it happens
 477        that the constraint is added during the search (i.e., with state() ==
 478        IN_SEARCH or state() == IN_ROOT_NODE). When a constraint is
 479        added during a search, it applies only to the subtree of the search tree
 480        rooted at the current node, and will be automatically removed by
 481        backtracking.
 482
 483        This method does not take ownership of the constraint. If the constraint
 484        has been created by any factory method (Solver::MakeXXX), it will
 485        automatically be deleted. However, power users who implement their own
 486        constraints should do: solver.AddConstraint(solver.RevAlloc(new
 487        MyConstraint(...));
 488        """
 489        return _pywrapcp.Solver_AddConstraint(self, c)
 490
 491    def Solve(self, *args):
 492        return _pywrapcp.Solver_Solve(self, *args)
 493
 494    def NewSearch(self, *args):
 495        return _pywrapcp.Solver_NewSearch(self, *args)
 496
 497    def NextSolution(self):
 498        return _pywrapcp.Solver_NextSolution(self)
 499
 500    def RestartSearch(self):
 501        return _pywrapcp.Solver_RestartSearch(self)
 502
 503    def EndSearch(self):
 504        return _pywrapcp.Solver_EndSearch(self)
 505
 506    def SolveAndCommit(self, *args):
 507        return _pywrapcp.Solver_SolveAndCommit(self, *args)
 508
 509    def CheckAssignment(self, solution):
 510        r""" Checks whether the given assignment satisfies all relevant constraints."""
 511        return _pywrapcp.Solver_CheckAssignment(self, solution)
 512
 513    def CheckConstraint(self, ct):
 514        r"""
 515        Checks whether adding this constraint will lead to an immediate
 516        failure. It will return false if the model is already inconsistent, or if
 517        adding the constraint makes it inconsistent.
 518        """
 519        return _pywrapcp.Solver_CheckConstraint(self, ct)
 520
 521    def Fail(self):
 522        r""" Abandon the current branch in the search tree. A backtrack will follow."""
 523        return _pywrapcp.Solver_Fail(self)
 524
 525    @staticmethod
 526    def MemoryUsage():
 527        r""" Current memory usage in bytes"""
 528        return _pywrapcp.Solver_MemoryUsage()
 529
 530    def WallTime(self):
 531        r"""
 532        DEPRECATED: Use Now() instead.
 533        Time elapsed, in ms since the creation of the solver.
 534        """
 535        return _pywrapcp.Solver_WallTime(self)
 536
 537    def Branches(self):
 538        r""" The number of branches explored since the creation of the solver."""
 539        return _pywrapcp.Solver_Branches(self)
 540
 541    def Solutions(self):
 542        r""" The number of solutions found since the start of the search."""
 543        return _pywrapcp.Solver_Solutions(self)
 544
 545    def Failures(self):
 546        r""" The number of failures encountered since the creation of the solver."""
 547        return _pywrapcp.Solver_Failures(self)
 548
 549    def AcceptedNeighbors(self):
 550        r""" The number of accepted neighbors."""
 551        return _pywrapcp.Solver_AcceptedNeighbors(self)
 552
 553    def Stamp(self):
 554        r"""
 555        The stamp indicates how many moves in the search tree we have performed.
 556        It is useful to detect if we need to update same lazy structures.
 557        """
 558        return _pywrapcp.Solver_Stamp(self)
 559
 560    def FailStamp(self):
 561        r""" The fail_stamp() is incremented after each backtrack."""
 562        return _pywrapcp.Solver_FailStamp(self)
 563
 564    def IntVar(self, *args):
 565        r"""
 566        *Overload 1:*
 567        MakeIntVar will create the best range based int var for the bounds given.
 568
 569        |
 570
 571        *Overload 2:*
 572        MakeIntVar will create a variable with the given sparse domain.
 573
 574        |
 575
 576        *Overload 3:*
 577        MakeIntVar will create a variable with the given sparse domain.
 578
 579        |
 580
 581        *Overload 4:*
 582        MakeIntVar will create the best range based int var for the bounds given.
 583
 584        |
 585
 586        *Overload 5:*
 587        MakeIntVar will create a variable with the given sparse domain.
 588
 589        |
 590
 591        *Overload 6:*
 592        MakeIntVar will create a variable with the given sparse domain.
 593        """
 594        return _pywrapcp.Solver_IntVar(self, *args)
 595
 596    def BoolVar(self, *args):
 597        r"""
 598        *Overload 1:*
 599        MakeBoolVar will create a variable with a {0, 1} domain.
 600
 601        |
 602
 603        *Overload 2:*
 604        MakeBoolVar will create a variable with a {0, 1} domain.
 605        """
 606        return _pywrapcp.Solver_BoolVar(self, *args)
 607
 608    def IntConst(self, *args):
 609        r"""
 610        *Overload 1:*
 611        IntConst will create a constant expression.
 612
 613        |
 614
 615        *Overload 2:*
 616        IntConst will create a constant expression.
 617        """
 618        return _pywrapcp.Solver_IntConst(self, *args)
 619
 620    def Sum(self, vars):
 621        r""" sum of all vars."""
 622        return _pywrapcp.Solver_Sum(self, vars)
 623
 624    def ScalProd(self, *args):
 625        r"""
 626        *Overload 1:*
 627        scalar product
 628
 629        |
 630
 631        *Overload 2:*
 632        scalar product
 633        """
 634        return _pywrapcp.Solver_ScalProd(self, *args)
 635
 636    def MonotonicElement(self, values, increasing, index):
 637        r"""
 638        Function based element. The constraint takes ownership of the
 639        callback.  The callback must be monotonic. It must be able to
 640        cope with any possible value in the domain of 'index'
 641        (potentially negative ones too). Furtermore, monotonicity is not
 642        checked. Thus giving a non-monotonic function, or specifying an
 643        incorrect increasing parameter will result in undefined behavior.
 644        """
 645        return _pywrapcp.Solver_MonotonicElement(self, values, increasing, index)
 646
 647    def Element(self, *args):
 648        r"""
 649        *Overload 1:*
 650        values[index]
 651
 652        |
 653
 654        *Overload 2:*
 655        values[index]
 656
 657        |
 658
 659        *Overload 3:*
 660        Function-based element. The constraint takes ownership of the
 661        callback. The callback must be able to cope with any possible
 662        value in the domain of 'index' (potentially negative ones too).
 663
 664        |
 665
 666        *Overload 4:*
 667        2D version of function-based element expression, values(expr1, expr2).
 668
 669        |
 670
 671        *Overload 5:*
 672        vars[expr]
 673        """
 674        return _pywrapcp.Solver_Element(self, *args)
 675
 676    def IndexExpression(self, vars, value):
 677        r"""
 678        Returns the expression expr such that vars[expr] == value.
 679        It assumes that vars are all different.
 680        """
 681        return _pywrapcp.Solver_IndexExpression(self, vars, value)
 682
 683    def Min(self, *args):
 684        r"""
 685        *Overload 1:*
 686        std::min(vars)
 687
 688        |
 689
 690        *Overload 2:*
 691        std::min (left, right)
 692
 693        |
 694
 695        *Overload 3:*
 696        std::min(expr, value)
 697
 698        |
 699
 700        *Overload 4:*
 701        std::min(expr, value)
 702        """
 703        return _pywrapcp.Solver_Min(self, *args)
 704
 705    def Max(self, *args):
 706        r"""
 707        *Overload 1:*
 708        std::max(vars)
 709
 710        |
 711
 712        *Overload 2:*
 713        std::max(left, right)
 714
 715        |
 716
 717        *Overload 3:*
 718        std::max(expr, value)
 719
 720        |
 721
 722        *Overload 4:*
 723        std::max(expr, value)
 724        """
 725        return _pywrapcp.Solver_Max(self, *args)
 726
 727    def ConvexPiecewiseExpr(self, expr, early_cost, early_date, late_date, late_cost):
 728        r""" Convex piecewise function."""
 729        return _pywrapcp.Solver_ConvexPiecewiseExpr(self, expr, early_cost, early_date, late_date, late_cost)
 730
 731    def SemiContinuousExpr(self, expr, fixed_charge, step):
 732        r"""
 733        Semi continuous Expression (x <= 0 -> f(x) = 0; x > 0 -> f(x) = ax + b)
 734        a >= 0 and b >= 0
 735        """
 736        return _pywrapcp.Solver_SemiContinuousExpr(self, expr, fixed_charge, step)
 737
 738    def ConditionalExpression(self, condition, expr, unperformed_value):
 739        r""" Conditional Expr condition ? expr : unperformed_value"""
 740        return _pywrapcp.Solver_ConditionalExpression(self, condition, expr, unperformed_value)
 741
 742    def TrueConstraint(self):
 743        r""" This constraint always succeeds."""
 744        return _pywrapcp.Solver_TrueConstraint(self)
 745
 746    def FalseConstraint(self, *args):
 747        return _pywrapcp.Solver_FalseConstraint(self, *args)
 748
 749    def IsEqualCstCt(self, var, value, boolvar):
 750        r""" boolvar == (var == value)"""
 751        return _pywrapcp.Solver_IsEqualCstCt(self, var, value, boolvar)
 752
 753    def IsEqualCstVar(self, var, value):
 754        r""" status var of (var == value)"""
 755        return _pywrapcp.Solver_IsEqualCstVar(self, var, value)
 756
 757    def IsEqualCt(self, v1, v2, b):
 758        r""" b == (v1 == v2)"""
 759        return _pywrapcp.Solver_IsEqualCt(self, v1, v2, b)
 760
 761    def IsEqualVar(self, v1, v2):
 762        r""" status var of (v1 == v2)"""
 763        return _pywrapcp.Solver_IsEqualVar(self, v1, v2)
 764
 765    def IsDifferentCstCt(self, var, value, boolvar):
 766        r""" boolvar == (var != value)"""
 767        return _pywrapcp.Solver_IsDifferentCstCt(self, var, value, boolvar)
 768
 769    def IsDifferentCstVar(self, var, value):
 770        r""" status var of (var != value)"""
 771        return _pywrapcp.Solver_IsDifferentCstVar(self, var, value)
 772
 773    def IsDifferentVar(self, v1, v2):
 774        r""" status var of (v1 != v2)"""
 775        return _pywrapcp.Solver_IsDifferentVar(self, v1, v2)
 776
 777    def IsDifferentCt(self, v1, v2, b):
 778        r""" b == (v1 != v2)"""
 779        return _pywrapcp.Solver_IsDifferentCt(self, v1, v2, b)
 780
 781    def IsLessOrEqualCstCt(self, var, value, boolvar):
 782        r""" boolvar == (var <= value)"""
 783        return _pywrapcp.Solver_IsLessOrEqualCstCt(self, var, value, boolvar)
 784
 785    def IsLessOrEqualCstVar(self, var, value):
 786        r""" status var of (var <= value)"""
 787        return _pywrapcp.Solver_IsLessOrEqualCstVar(self, var, value)
 788
 789    def IsLessOrEqualVar(self, left, right):
 790        r""" status var of (left <= right)"""
 791        return _pywrapcp.Solver_IsLessOrEqualVar(self, left, right)
 792
 793    def IsLessOrEqualCt(self, left, right, b):
 794        r""" b == (left <= right)"""
 795        return _pywrapcp.Solver_IsLessOrEqualCt(self, left, right, b)
 796
 797    def IsGreaterOrEqualCstCt(self, var, value, boolvar):
 798        r""" boolvar == (var >= value)"""
 799        return _pywrapcp.Solver_IsGreaterOrEqualCstCt(self, var, value, boolvar)
 800
 801    def IsGreaterOrEqualCstVar(self, var, value):
 802        r""" status var of (var >= value)"""
 803        return _pywrapcp.Solver_IsGreaterOrEqualCstVar(self, var, value)
 804
 805    def IsGreaterOrEqualVar(self, left, right):
 806        r""" status var of (left >= right)"""
 807        return _pywrapcp.Solver_IsGreaterOrEqualVar(self, left, right)
 808
 809    def IsGreaterOrEqualCt(self, left, right, b):
 810        r""" b == (left >= right)"""
 811        return _pywrapcp.Solver_IsGreaterOrEqualCt(self, left, right, b)
 812
 813    def IsGreaterCstCt(self, v, c, b):
 814        r""" b == (v > c)"""
 815        return _pywrapcp.Solver_IsGreaterCstCt(self, v, c, b)
 816
 817    def IsGreaterCstVar(self, var, value):
 818        r""" status var of (var > value)"""
 819        return _pywrapcp.Solver_IsGreaterCstVar(self, var, value)
 820
 821    def IsGreaterVar(self, left, right):
 822        r""" status var of (left > right)"""
 823        return _pywrapcp.Solver_IsGreaterVar(self, left, right)
 824
 825    def IsGreaterCt(self, left, right, b):
 826        r""" b == (left > right)"""
 827        return _pywrapcp.Solver_IsGreaterCt(self, left, right, b)
 828
 829    def IsLessCstCt(self, v, c, b):
 830        r""" b == (v < c)"""
 831        return _pywrapcp.Solver_IsLessCstCt(self, v, c, b)
 832
 833    def IsLessCstVar(self, var, value):
 834        r""" status var of (var < value)"""
 835        return _pywrapcp.Solver_IsLessCstVar(self, var, value)
 836
 837    def IsLessVar(self, left, right):
 838        r""" status var of (left < right)"""
 839        return _pywrapcp.Solver_IsLessVar(self, left, right)
 840
 841    def IsLessCt(self, left, right, b):
 842        r""" b == (left < right)"""
 843        return _pywrapcp.Solver_IsLessCt(self, left, right, b)
 844
 845    def SumLessOrEqual(self, vars, cst):
 846        r""" Variation on arrays."""
 847        return _pywrapcp.Solver_SumLessOrEqual(self, vars, cst)
 848
 849    def SumGreaterOrEqual(self, vars, cst):
 850        return _pywrapcp.Solver_SumGreaterOrEqual(self, vars, cst)
 851
 852    def SumEquality(self, *args):
 853        return _pywrapcp.Solver_SumEquality(self, *args)
 854
 855    def ScalProdEquality(self, *args):
 856        return _pywrapcp.Solver_ScalProdEquality(self, *args)
 857
 858    def ScalProdGreaterOrEqual(self, *args):
 859        return _pywrapcp.Solver_ScalProdGreaterOrEqual(self, *args)
 860
 861    def ScalProdLessOrEqual(self, *args):
 862        return _pywrapcp.Solver_ScalProdLessOrEqual(self, *args)
 863
 864    def MinEquality(self, vars, min_var):
 865        return _pywrapcp.Solver_MinEquality(self, vars, min_var)
 866
 867    def MaxEquality(self, vars, max_var):
 868        return _pywrapcp.Solver_MaxEquality(self, vars, max_var)
 869
 870    def ElementEquality(self, *args):
 871        return _pywrapcp.Solver_ElementEquality(self, *args)
 872
 873    def AbsEquality(self, var, abs_var):
 874        r""" Creates the constraint abs(var) == abs_var."""
 875        return _pywrapcp.Solver_AbsEquality(self, var, abs_var)
 876
 877    def IndexOfConstraint(self, vars, index, target):
 878        r"""
 879        This constraint is a special case of the element constraint with
 880        an array of integer variables, where the variables are all
 881        different and the index variable is constrained such that
 882        vars[index] == target.
 883        """
 884        return _pywrapcp.Solver_IndexOfConstraint(self, vars, index, target)
 885
 886    def ConstraintInitialPropagateCallback(self, ct):
 887        r"""
 888        This method is a specialized case of the MakeConstraintDemon
 889        method to call the InitiatePropagate of the constraint 'ct'.
 890        """
 891        return _pywrapcp.Solver_ConstraintInitialPropagateCallback(self, ct)
 892
 893    def DelayedConstraintInitialPropagateCallback(self, ct):
 894        r"""
 895        This method is a specialized case of the MakeConstraintDemon
 896        method to call the InitiatePropagate of the constraint 'ct' with
 897        low priority.
 898        """
 899        return _pywrapcp.Solver_DelayedConstraintInitialPropagateCallback(self, ct)
 900
 901    def ClosureDemon(self, closure):
 902        r""" Creates a demon from a closure."""
 903        return _pywrapcp.Solver_ClosureDemon(self, closure)
 904
 905    def BetweenCt(self, expr, l, u):
 906        r""" (l <= expr <= u)"""
 907        return _pywrapcp.Solver_BetweenCt(self, expr, l, u)
 908
 909    def IsBetweenCt(self, expr, l, u, b):
 910        r""" b == (l <= expr <= u)"""
 911        return _pywrapcp.Solver_IsBetweenCt(self, expr, l, u, b)
 912
 913    def IsBetweenVar(self, v, l, u):
 914        return _pywrapcp.Solver_IsBetweenVar(self, v, l, u)
 915
 916    def MemberCt(self, *args):
 917        return _pywrapcp.Solver_MemberCt(self, *args)
 918
 919    def NotMemberCt(self, *args):
 920        r"""
 921        *Overload 1:*
 922        expr not in set.
 923
 924        |
 925
 926        *Overload 2:*
 927        expr should not be in the list of forbidden intervals [start[i]..end[i]].
 928
 929        |
 930
 931        *Overload 3:*
 932        expr should not be in the list of forbidden intervals [start[i]..end[i]].
 933        """
 934        return _pywrapcp.Solver_NotMemberCt(self, *args)
 935
 936    def IsMemberCt(self, *args):
 937        return _pywrapcp.Solver_IsMemberCt(self, *args)
 938
 939    def IsMemberVar(self, *args):
 940        return _pywrapcp.Solver_IsMemberVar(self, *args)
 941
 942    def Count(self, *args):
 943        r"""
 944        *Overload 1:*
 945        |{i | vars[i] == value}| == max_count
 946
 947        |
 948
 949        *Overload 2:*
 950        |{i | vars[i] == value}| == max_count
 951        """
 952        return _pywrapcp.Solver_Count(self, *args)
 953
 954    def Distribute(self, *args):
 955        r"""
 956        *Overload 1:*
 957        Aggregated version of count:  |{i | v[i] == values[j]}| == cards[j]
 958
 959        |
 960
 961        *Overload 2:*
 962        Aggregated version of count:  |{i | v[i] == values[j]}| == cards[j]
 963
 964        |
 965
 966        *Overload 3:*
 967        Aggregated version of count:  |{i | v[i] == j}| == cards[j]
 968
 969        |
 970
 971        *Overload 4:*
 972        Aggregated version of count with bounded cardinalities:
 973        forall j in 0 .. card_size - 1: card_min <= |{i | v[i] == j}| <= card_max
 974
 975        |
 976
 977        *Overload 5:*
 978        Aggregated version of count with bounded cardinalities:
 979        forall j in 0 .. card_size - 1:
 980           card_min[j] <= |{i | v[i] == j}| <= card_max[j]
 981
 982        |
 983
 984        *Overload 6:*
 985        Aggregated version of count with bounded cardinalities:
 986        forall j in 0 .. card_size - 1:
 987           card_min[j] <= |{i | v[i] == j}| <= card_max[j]
 988
 989        |
 990
 991        *Overload 7:*
 992        Aggregated version of count with bounded cardinalities:
 993        forall j in 0 .. card_size - 1:
 994           card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j]
 995
 996        |
 997
 998        *Overload 8:*
 999        Aggregated version of count with bounded cardinalities:
1000        forall j in 0 .. card_size - 1:
1001           card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j]
1002        """
1003        return _pywrapcp.Solver_Distribute(self, *args)
1004
1005    def Deviation(self, vars, deviation_var, total_sum):
1006        r"""
1007        Deviation constraint:
1008        sum_i |n * vars[i] - total_sum| <= deviation_var and
1009        sum_i vars[i] == total_sum
1010        n = #vars
1011        """
1012        return _pywrapcp.Solver_Deviation(self, vars, deviation_var, total_sum)
1013
1014    def AllDifferent(self, *args):
1015        r"""
1016        *Overload 1:*
1017        All variables are pairwise different. This corresponds to the
1018        stronger version of the propagation algorithm.
1019
1020        |
1021
1022        *Overload 2:*
1023        All variables are pairwise different.  If 'stronger_propagation'
1024        is true, stronger, and potentially slower propagation will
1025        occur. This API will be deprecated in the future.
1026        """
1027        return _pywrapcp.Solver_AllDifferent(self, *args)
1028
1029    def AllDifferentExcept(self, vars, escape_value):
1030        r"""
1031        All variables are pairwise different, unless they are assigned to
1032        the escape value.
1033        """
1034        return _pywrapcp.Solver_AllDifferentExcept(self, vars, escape_value)
1035
1036    def SortingConstraint(self, vars, sorted):
1037        r"""
1038        Creates a constraint binding the arrays of variables "vars" and
1039        "sorted_vars": sorted_vars[0] must be equal to the minimum of all
1040        variables in vars, and so on: the value of sorted_vars[i] must be
1041        equal to the i-th value of variables invars.
1042
1043        This constraint propagates in both directions: from "vars" to
1044        "sorted_vars" and vice-versa.
1045
1046        Behind the scenes, this constraint maintains that:
1047          - sorted is always increasing.
1048          - whatever the values of vars, there exists a permutation that
1049            injects its values into the sorted variables.
1050
1051        For more info, please have a look at:
1052          https://mpi-inf.mpg.de/~mehlhorn/ftp/Mehlhorn-Thiel.pdf
1053        """
1054        return _pywrapcp.Solver_SortingConstraint(self, vars, sorted)
1055
1056    def LexicalLess(self, left, right):
1057        r"""
1058        Creates a constraint that enforces that left is lexicographically less
1059        than right.
1060        """
1061        return _pywrapcp.Solver_LexicalLess(self, left, right)
1062
1063    def LexicalLessOrEqual(self, left, right):
1064        r"""
1065        Creates a constraint that enforces that left is lexicographically less
1066        than or equal to right.
1067        """
1068        return _pywrapcp.Solver_LexicalLessOrEqual(self, left, right)
1069
1070    def InversePermutationConstraint(self, left, right):
1071        r"""
1072        Creates a constraint that enforces that 'left' and 'right' both
1073        represent permutations of [0..left.size()-1], and that 'right' is
1074        the inverse permutation of 'left', i.e. for all i in
1075        [0..left.size()-1], right[left[i]] = i.
1076        """
1077        return _pywrapcp.Solver_InversePermutationConstraint(self, left, right)
1078
1079    def NullIntersect(self, first_vars, second_vars):
1080        r"""
1081        Creates a constraint that states that all variables in the first
1082        vector are different from all variables in the second
1083        group. Thus the set of values in the first vector does not
1084        intersect with the set of values in the second vector.
1085        """
1086        return _pywrapcp.Solver_NullIntersect(self, first_vars, second_vars)
1087
1088    def NullIntersectExcept(self, first_vars, second_vars, escape_value):
1089        r"""
1090        Creates a constraint that states that all variables in the first
1091        vector are different from all variables from the second group,
1092        unless they are assigned to the escape value. Thus the set of
1093        values in the first vector minus the escape value does not
1094        intersect with the set of values in the second vector.
1095        """
1096        return _pywrapcp.Solver_NullIntersectExcept(self, first_vars, second_vars, escape_value)
1097
1098    def Circuit(self, nexts):
1099        r""" Force the "nexts" variable to create a complete Hamiltonian path."""
1100        return _pywrapcp.Solver_Circuit(self, nexts)
1101
1102    def SubCircuit(self, nexts):
1103        r"""
1104        Force the "nexts" variable to create a complete Hamiltonian path
1105        for those that do not loop upon themselves.
1106        """
1107        return _pywrapcp.Solver_SubCircuit(self, nexts)
1108
1109    def DelayedPathCumul(self, nexts, active, cumuls, transits):
1110        r"""
1111        Delayed version of the same constraint: propagation on the nexts variables
1112        is delayed until all constraints have propagated.
1113        """
1114        return _pywrapcp.Solver_DelayedPathCumul(self, nexts, active, cumuls, transits)
1115
1116    def PathCumul(self, *args):
1117        r"""
1118        *Overload 1:*
1119        Creates a constraint which accumulates values along a path such that:
1120        cumuls[next[i]] = cumuls[i] + transits[i].
1121        Active variables indicate if the corresponding next variable is active;
1122        this could be useful to model unperformed nodes in a routing problem.
1123
1124        |
1125
1126        *Overload 2:*
1127        Creates a constraint which accumulates values along a path such that:
1128        cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]).
1129        Active variables indicate if the corresponding next variable is active;
1130        this could be useful to model unperformed nodes in a routing problem.
1131        Ownership of transit_evaluator is taken and it must be a repeatable
1132        callback.
1133
1134        |
1135
1136        *Overload 3:*
1137        Creates a constraint which accumulates values along a path such that:
1138        cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]) + slacks[i].
1139        Active variables indicate if the corresponding next variable is active;
1140        this could be useful to model unperformed nodes in a routing problem.
1141        Ownership of transit_evaluator is taken and it must be a repeatable
1142        callback.
1143        """
1144        return _pywrapcp.Solver_PathCumul(self, *args)
1145
1146    def AllowedAssignments(self, *args):
1147        r"""
1148        *Overload 1:*
1149        This method creates a constraint where the graph of the relation
1150        between the variables is given in extension. There are 'arity'
1151        variables involved in the relation and the graph is given by a
1152        integer tuple set.
1153
1154        |
1155
1156        *Overload 2:*
1157        Compatibility layer for Python API.
1158        """
1159        return _pywrapcp.Solver_AllowedAssignments(self, *args)
1160
1161    def TransitionConstraint(self, *args):
1162        return _pywrapcp.Solver_TransitionConstraint(self, *args)
1163
1164    def NonOverlappingBoxesConstraint(self, *args):
1165        return _pywrapcp.Solver_NonOverlappingBoxesConstraint(self, *args)
1166
1167    def Pack(self, vars, number_of_bins):
1168        r"""
1169        This constraint packs all variables onto 'number_of_bins'
1170        variables.  For any given variable, a value of 'number_of_bins'
1171        indicates that the variable is not assigned to any bin.
1172        Dimensions, i.e., cumulative constraints on this packing, can be
1173        added directly from the pack class.
1174        """
1175        return _pywrapcp.Solver_Pack(self, vars, number_of_bins)
1176
1177    def FixedDurationIntervalVar(self, *args):
1178        r"""
1179        *Overload 1:*
1180        Creates an interval var with a fixed duration. The duration must
1181        be greater than 0. If optional is true, then the interval can be
1182        performed or unperformed. If optional is false, then the interval
1183        is always performed.
1184
1185        |
1186
1187        *Overload 2:*
1188        Creates a performed interval var with a fixed duration. The duration must
1189        be greater than 0.
1190
1191        |
1192
1193        *Overload 3:*
1194        Creates an interval var with a fixed duration, and performed_variable.
1195        The duration must be greater than 0.
1196        """
1197        return _pywrapcp.Solver_FixedDurationIntervalVar(self, *args)
1198
1199    def FixedInterval(self, start, duration, name):
1200        r""" Creates a fixed and performed interval."""
1201        return _pywrapcp.Solver_FixedInterval(self, start, duration, name)
1202
1203    def IntervalVar(self, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name):
1204        r"""
1205        Creates an interval var by specifying the bounds on start,
1206        duration, and end.
1207        """
1208        return _pywrapcp.Solver_IntervalVar(self, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name)
1209
1210    def MirrorInterval(self, interval_var):
1211        r"""
1212        Creates an interval var that is the mirror image of the given one, that
1213        is, the interval var obtained by reversing the axis.
1214        """
1215        return _pywrapcp.Solver_MirrorInterval(self, interval_var)
1216
1217    def FixedDurationStartSyncedOnStartIntervalVar(self, interval_var, duration, offset):
1218        r"""
1219        Creates an interval var with a fixed duration whose start is
1220        synchronized with the start of another interval, with a given
1221        offset. The performed status is also in sync with the performed
1222        status of the given interval variable.
1223        """
1224        return _pywrapcp.Solver_FixedDurationStartSyncedOnStartIntervalVar(self, interval_var, duration, offset)
1225
1226    def FixedDurationStartSyncedOnEndIntervalVar(self, interval_var, duration, offset):
1227        r"""
1228        Creates an interval var with a fixed duration whose start is
1229        synchronized with the end of another interval, with a given
1230        offset. The performed status is also in sync with the performed
1231        status of the given interval variable.
1232        """
1233        return _pywrapcp.Solver_FixedDurationStartSyncedOnEndIntervalVar(self, interval_var, duration, offset)
1234
1235    def FixedDurationEndSyncedOnStartIntervalVar(self, interval_var, duration, offset):
1236        r"""
1237        Creates an interval var with a fixed duration whose end is
1238        synchronized with the start of another interval, with a given
1239        offset. The performed status is also in sync with the performed
1240        status of the given interval variable.
1241        """
1242        return _pywrapcp.Solver_FixedDurationEndSyncedOnStartIntervalVar(self, interval_var, duration, offset)
1243
1244    def FixedDurationEndSyncedOnEndIntervalVar(self, interval_var, duration, offset):
1245        r"""
1246        Creates an interval var with a fixed duration whose end is
1247        synchronized with the end of another interval, with a given
1248        offset. The performed status is also in sync with the performed
1249        status of the given interval variable.
1250        """
1251        return _pywrapcp.Solver_FixedDurationEndSyncedOnEndIntervalVar(self, interval_var, duration, offset)
1252
1253    def IntervalRelaxedMin(self, interval_var):
1254        r"""
1255         Creates and returns an interval variable that wraps around the given one,
1256         relaxing the min start and end. Relaxing means making unbounded when
1257         optional. If the variable is non-optional, this method returns
1258         interval_var.
1259
1260         More precisely, such an interval variable behaves as follows:
1261        When the underlying must be performed, the returned interval variable
1262             behaves exactly as the underlying;
1263        When the underlying may or may not be performed, the returned interval
1264             variable behaves like the underlying, except that it is unbounded on
1265             the min side;
1266        When the underlying cannot be performed, the returned interval variable
1267             is of duration 0 and must be performed in an interval unbounded on
1268             both sides.
1269
1270         This is very useful to implement propagators that may only modify
1271         the start max or end max.
1272        """
1273        return _pywrapcp.Solver_IntervalRelaxedMin(self, interval_var)
1274
1275    def IntervalRelaxedMax(self, interval_var):
1276        r"""
1277         Creates and returns an interval variable that wraps around the given one,
1278         relaxing the max start and end. Relaxing means making unbounded when
1279         optional. If the variable is non optional, this method returns
1280         interval_var.
1281
1282         More precisely, such an interval variable behaves as follows:
1283        When the underlying must be performed, the returned interval variable
1284             behaves exactly as the underlying;
1285        When the underlying may or may not be performed, the returned interval
1286             variable behaves like the underlying, except that it is unbounded on
1287             the max side;
1288        When the underlying cannot be performed, the returned interval variable
1289             is of duration 0 and must be performed in an interval unbounded on
1290             both sides.
1291
1292         This is very useful for implementing propagators that may only modify
1293         the start min or end min.
1294        """
1295        return _pywrapcp.Solver_IntervalRelaxedMax(self, interval_var)
1296
1297    def TemporalDisjunction(self, *args):
1298        r"""
1299        *Overload 1:*
1300        This constraint implements a temporal disjunction between two
1301        interval vars t1 and t2. 'alt' indicates which alternative was
1302        chosen (alt == 0 is equivalent to t1 before t2).
1303
1304        |
1305
1306        *Overload 2:*
1307        This constraint implements a temporal disjunction between two
1308        interval vars.
1309        """
1310        return _pywrapcp.Solver_TemporalDisjunction(self, *args)
1311
1312    def DisjunctiveConstraint(self, intervals, name):
1313        r"""
1314        This constraint forces all interval vars into an non-overlapping
1315        sequence. Intervals with zero duration can be scheduled anywhere.
1316        """
1317        return _pywrapcp.Solver_DisjunctiveConstraint(self, intervals, name)
1318
1319    def Cumulative(self, *args):
1320        r"""
1321        *Overload 1:*
1322        This constraint forces that, for any integer t, the sum of the demands
1323        corresponding to an interval containing t does not exceed the given
1324        capacity.
1325
1326        Intervals and demands should be vectors of equal size.
1327
1328        Demands should only contain non-negative values. Zero values are
1329        supported, and the corresponding intervals are filtered out, as they
1330        neither impact nor are impacted by this constraint.
1331
1332        |
1333
1334        *Overload 2:*
1335        This constraint forces that, for any integer t, the sum of the demands
1336        corresponding to an interval containing t does not exceed the given
1337        capacity.
1338
1339        Intervals and demands should be vectors of equal size.
1340
1341        Demands should only contain non-negative values. Zero values are
1342        supported, and the corresponding intervals are filtered out, as they
1343        neither impact nor are impacted by this constraint.
1344
1345        |
1346
1347        *Overload 3:*
1348        This constraint forces that, for any integer t, the sum of the demands
1349        corresponding to an interval containing t does not exceed the given
1350        capacity.
1351
1352        Intervals and demands should be vectors of equal size.
1353
1354        Demands should only contain non-negative values. Zero values are
1355        supported, and the corresponding intervals are filtered out, as they
1356        neither impact nor are impacted by this constraint.
1357
1358        |
1359
1360        *Overload 4:*
1361        This constraint enforces that, for any integer t, the sum of the demands
1362        corresponding to an interval containing t does not exceed the given
1363        capacity.
1364
1365        Intervals and demands should be vectors of equal size.
1366
1367        Demands should only contain non-negative values. Zero values are
1368        supported, and the corresponding intervals are filtered out, as they
1369        neither impact nor are impacted by this constraint.
1370
1371        |
1372
1373        *Overload 5:*
1374        This constraint enforces that, for any integer t, the sum of demands
1375        corresponding to an interval containing t does not exceed the given
1376        capacity.
1377
1378        Intervals and demands should be vectors of equal size.
1379
1380        Demands should be positive.
1381
1382        |
1383
1384        *Overload 6:*
1385        This constraint enforces that, for any integer t, the sum of demands
1386        corresponding to an interval containing t does not exceed the given
1387        capacity.
1388
1389        Intervals and demands should be vectors of equal size.
1390
1391        Demands should be positive.
1392        """
1393        return _pywrapcp.Solver_Cumulative(self, *args)
1394
1395    def Cover(self, vars, target_var):
1396        r"""
1397        This constraint states that the target_var is the convex hull of
1398        the intervals. If none of the interval variables is performed,
1399        then the target var is unperformed too. Also, if the target
1400        variable is unperformed, then all the intervals variables are
1401        unperformed too.
1402        """
1403        return _pywrapcp.Solver_Cover(self, vars, target_var)
1404
1405    def Assignment(self, *args):
1406        r"""
1407        *Overload 1:*
1408        This method creates an empty assignment.
1409
1410        |
1411
1412        *Overload 2:*
1413        This method creates an assignment which is a copy of 'a'.
1414        """
1415        return _pywrapcp.Solver_Assignment(self, *args)
1416
1417    def FirstSolutionCollector(self, *args):
1418        r"""
1419        *Overload 1:*
1420        Collect the first solution of the search.
1421
1422        |
1423
1424        *Overload 2:*
1425        Collect the first solution of the search. The variables will need to
1426        be added later.
1427        """
1428        return _pywrapcp.Solver_FirstSolutionCollector(self, *args)
1429
1430    def LastSolutionCollector(self, *args):
1431        r"""
1432        *Overload 1:*
1433        Collect the last solution of the search.
1434
1435        |
1436
1437        *Overload 2:*
1438        Collect the last solution of the search. The variables will need to
1439        be added later.
1440        """
1441        return _pywrapcp.Solver_LastSolutionCollector(self, *args)
1442
1443    def BestValueSolutionCollector(self, *args):
1444        r"""
1445        *Overload 1:*
1446        Collect the solution corresponding to the optimal value of the objective
1447        of 'assignment'; if 'assignment' does not have an objective no solution is
1448        collected. This collector only collects one solution corresponding to the
1449        best objective value (the first one found).
1450
1451        |
1452
1453        *Overload 2:*
1454        Collect the solution corresponding to the optimal value of the
1455        objective of the internal assignment; if this assignment does not have an
1456        objective no solution is collected. This collector only collects one
1457        solution corresponding to the best objective value (the first one found).
1458        The variables and objective(s) will need to be added later.
1459        """
1460        return _pywrapcp.Solver_BestValueSolutionCollector(self, *args)
1461
1462    def AllSolutionCollector(self, *args):
1463        r"""
1464        *Overload 1:*
1465        Collect all solutions of the search.
1466
1467        |
1468
1469        *Overload 2:*
1470        Collect all solutions of the search. The variables will need to
1471        be added later.
1472        """
1473        return _pywrapcp.Solver_AllSolutionCollector(self, *args)
1474
1475    def Minimize(self, v, step):
1476        r""" Creates a minimization objective."""
1477        return _pywrapcp.Solver_Minimize(self, v, step)
1478
1479    def Maximize(self, v, step):
1480        r""" Creates a maximization objective."""
1481        return _pywrapcp.Solver_Maximize(self, v, step)
1482
1483    def Optimize(self, maximize, v, step):
1484        r""" Creates a objective with a given sense (true = maximization)."""
1485        return _pywrapcp.Solver_Optimize(self, maximize, v, step)
1486
1487    def WeightedMinimize(self, *args):
1488        r"""
1489        *Overload 1:*
1490        Creates a minimization weighted objective. The actual objective is
1491        scalar_prod(sub_objectives, weights).
1492
1493        |
1494
1495        *Overload 2:*
1496        Creates a minimization weighted objective. The actual objective is
1497        scalar_prod(sub_objectives, weights).
1498        """
1499        return _pywrapcp.Solver_WeightedMinimize(self, *args)
1500
1501    def WeightedMaximize(self, *args):
1502        r"""
1503        *Overload 1:*
1504        Creates a maximization weigthed objective.
1505
1506        |
1507
1508        *Overload 2:*
1509        Creates a maximization weigthed objective.
1510        """
1511        return _pywrapcp.Solver_WeightedMaximize(self, *args)
1512
1513    def WeightedOptimize(self, *args):
1514        r"""
1515        *Overload 1:*
1516        Creates a weighted objective with a given sense (true = maximization).
1517
1518        |
1519
1520        *Overload 2:*
1521        Creates a weighted objective with a given sense (true = maximization).
1522        """
1523        return _pywrapcp.Solver_WeightedOptimize(self, *args)
1524
1525    def TabuSearch(self, maximize, objective, step, vars, keep_tenure, forbid_tenure, tabu_factor):
1526        r"""
1527        MetaHeuristics which try to get the search out of local optima.
1528        Creates a Tabu Search monitor.
1529        In the context of local search the behavior is similar to MakeOptimize(),
1530        creating an objective in a given sense. The behavior differs once a local
1531        optimum is reached: thereafter solutions which degrade the value of the
1532        objective are allowed if they are not "tabu". A solution is "tabu" if it
1533        doesn't respect the following rules:
1534        - improving the best solution found so far
1535        - variables in the "keep" list must keep their value, variables in the
1536        "forbid" list must not take the value they have in the list.
1537        Variables with new values enter the tabu lists after each new solution
1538        found and leave the lists after a given number of iterations (called
1539        tenure). Only the variables passed to the method can enter the lists.
1540        The tabu criterion is softened by the tabu factor which gives the number
1541        of "tabu" violations which is tolerated; a factor of 1 means no violations
1542        allowed; a factor of 0 means all violations are allowed.
1543        """
1544        return _pywrapcp.Solver_TabuSearch(self, maximize, objective, step, vars, keep_tenure, forbid_tenure, tabu_factor)
1545
1546    def SimulatedAnnealing(self, maximize, v, step, initial_temperature):
1547        r""" Creates a Simulated Annealing monitor."""
1548        return _pywrapcp.Solver_SimulatedAnnealing(self, maximize, v, step, initial_temperature)
1549
1550    def LubyRestart(self, scale_factor):
1551        r"""
1552        This search monitor will restart the search periodically.
1553        At the iteration n, it will restart after scale_factor * Luby(n) failures
1554        where Luby is the Luby Strategy (i.e. 1 1 2 1 1 2 4 1 1 2 1 1 2 4 8...).
1555        """
1556        return _pywrapcp.Solver_LubyRestart(self, scale_factor)
1557
1558    def ConstantRestart(self, frequency):
1559        r"""
1560        This search monitor will restart the search periodically after 'frequency'
1561        failures.
1562        """
1563        return _pywrapcp.Solver_ConstantRestart(self, frequency)
1564
1565    def TimeLimit(self, *args):
1566        return _pywrapcp.Solver_TimeLimit(self, *args)
1567
1568    def BranchesLimit(self, branches):
1569        r"""
1570        Creates a search limit that constrains the number of branches
1571        explored in the search tree.
1572        """
1573        return _pywrapcp.Solver_BranchesLimit(self, branches)
1574
1575    def FailuresLimit(self, failures):
1576        r"""
1577        Creates a search limit that constrains the number of failures
1578        that can happen when exploring the search tree.
1579        """
1580        return _pywrapcp.Solver_FailuresLimit(self, failures)
1581
1582    def SolutionsLimit(self, solutions):
1583        r"""
1584        Creates a search limit that constrains the number of solutions found
1585        during the search.
1586        """
1587        return _pywrapcp.Solver_SolutionsLimit(self, solutions)
1588
1589    def Limit(self, *args):
1590        r"""
1591        *Overload 1:*
1592        Limits the search with the 'time', 'branches', 'failures' and
1593        'solutions' limits. 'smart_time_check' reduces the calls to the wall
1594
1595        |
1596
1597        *Overload 2:*
1598        Creates a search limit from its protobuf description
1599
1600        |
1601
1602        *Overload 3:*
1603        Creates a search limit that is reached when either of the underlying limit
1604        is reached. That is, the returned limit is more stringent than both
1605        argument limits.
1606        """
1607        return _pywrapcp.Solver_Limit(self, *args)
1608
1609    def CustomLimit(self, limiter):
1610        r"""
1611        Callback-based search limit. Search stops when limiter returns true; if
1612        this happens at a leaf the corresponding solution will be rejected.
1613        """
1614        return _pywrapcp.Solver_CustomLimit(self, limiter)
1615
1616    def SearchLog(self, *args):
1617        return _pywrapcp.Solver_SearchLog(self, *args)
1618
1619    def SearchTrace(self, prefix):
1620        r"""
1621        Creates a search monitor that will trace precisely the behavior of the
1622        search. Use this only for low level debugging.
1623        """
1624        return _pywrapcp.Solver_SearchTrace(self, prefix)
1625
1626    def PrintModelVisitor(self):
1627        r""" Prints the model."""
1628        return _pywrapcp.Solver_PrintModelVisitor(self)
1629
1630    def StatisticsModelVisitor(self):
1631        r""" Displays some nice statistics on the model."""
1632        return _pywrapcp.Solver_StatisticsModelVisitor(self)
1633
1634    def AssignVariableValue(self, var, val):
1635        r""" Decisions."""
1636        return _pywrapcp.Solver_AssignVariableValue(self, var, val)
1637
1638    def VariableLessOrEqualValue(self, var, value):
1639        return _pywrapcp.Solver_VariableLessOrEqualValue(self, var, value)
1640
1641    def VariableGreaterOrEqualValue(self, var, value):
1642        return _pywrapcp.Solver_VariableGreaterOrEqualValue(self, var, value)
1643
1644    def SplitVariableDomain(self, var, val, start_with_lower_half):
1645        return _pywrapcp.Solver_SplitVariableDomain(self, var, val, start_with_lower_half)
1646
1647    def AssignVariableValueOrFail(self, var, value):
1648        return _pywrapcp.Solver_AssignVariableValueOrFail(self, var, value)
1649
1650    def AssignVariablesValues(self, vars, values):
1651        return _pywrapcp.Solver_AssignVariablesValues(self, vars, values)
1652
1653    def FailDecision(self):
1654        return _pywrapcp.Solver_FailDecision(self)
1655
1656    def Decision(self, apply, refute):
1657        return _pywrapcp.Solver_Decision(self, apply, refute)
1658
1659    def Compose(self, dbs):
1660        return _pywrapcp.Solver_Compose(self, dbs)
1661
1662    def Try(self, dbs):
1663        return _pywrapcp.Solver_Try(self, dbs)
1664
1665    def DefaultPhase(self, *args):
1666        return _pywrapcp.Solver_DefaultPhase(self, *args)
1667
1668    def ScheduleOrPostpone(self, var, est, marker):
1669        r"""
1670        Returns a decision that tries to schedule a task at a given time.
1671        On the Apply branch, it will set that interval var as performed and set
1672        its start to 'est'. On the Refute branch, it will just update the
1673        'marker' to 'est' + 1. This decision is used in the
1674        INTERVAL_SET_TIMES_FORWARD strategy.
1675        """
1676        return _pywrapcp.Solver_ScheduleOrPostpone(self, var, est, marker)
1677
1678    def ScheduleOrExpedite(self, var, est, marker):
1679        r"""
1680        Returns a decision that tries to schedule a task at a given time.
1681        On the Apply branch, it will set that interval var as performed and set
1682        its end to 'est'. On the Refute branch, it will just update the
1683        'marker' to 'est' - 1. This decision is used in the
1684        INTERVAL_SET_TIMES_BACKWARD strategy.
1685        """
1686        return _pywrapcp.Solver_ScheduleOrExpedite(self, var, est, marker)
1687
1688    def RankFirstInterval(self, sequence, index):
1689        r"""
1690        Returns a decision that tries to rank first the ith interval var
1691        in the sequence variable.
1692        """
1693        return _pywrapcp.Solver_RankFirstInterval(self, sequence, index)
1694
1695    def RankLastInterval(self, sequence, index):
1696        r"""
1697        Returns a decision that tries to rank last the ith interval var
1698        in the sequence variable.
1699        """
1700        return _pywrapcp.Solver_RankLastInterval(self, sequence, index)
1701
1702    def Phase(self, *args):
1703        return _pywrapcp.Solver_Phase(self, *args)
1704
1705    def DecisionBuilderFromAssignment(self, assignment, db, vars):
1706        r"""
1707        Returns a decision builder for which the left-most leaf corresponds
1708        to assignment, the rest of the tree being explored using 'db'.
1709        """
1710        return _pywrapcp.Solver_DecisionBuilderFromAssignment(self, assignment, db, vars)
1711
1712    def ConstraintAdder(self, ct):
1713        r"""
1714        Returns a decision builder that will add the given constraint to
1715        the model.
1716        """
1717        return _pywrapcp.Solver_ConstraintAdder(self, ct)
1718
1719    def SolveOnce(self, db, monitors):
1720        return _pywrapcp.Solver_SolveOnce(self, db, monitors)
1721
1722    def NestedOptimize(self, *args):
1723        return _pywrapcp.Solver_NestedOptimize(self, *args)
1724
1725    def RestoreAssignment(self, assignment):
1726        r"""
1727        Returns a DecisionBuilder which restores an Assignment
1728        (calls void Assignment::Restore())
1729        """
1730        return _pywrapcp.Solver_RestoreAssignment(self, assignment)
1731
1732    def StoreAssignment(self, assignment):
1733        r"""
1734        Returns a DecisionBuilder which stores an Assignment
1735        (calls void Assignment::Store())
1736        """
1737        return _pywrapcp.Solver_StoreAssignment(self, assignment)
1738
1739    def Operator(self, *args):
1740        return _pywrapcp.Solver_Operator(self, *args)
1741
1742    def RandomLnsOperator(self, *args):
1743        return _pywrapcp.Solver_RandomLnsOperator(self, *args)
1744
1745    def MoveTowardTargetOperator(self, *args):
1746        r"""
1747        *Overload 1:*
1748        Creates a local search operator that tries to move the assignment of some
1749        variables toward a target. The target is given as an Assignment. This
1750        operator generates neighbors in which the only difference compared to the
1751        current state is that one variable that belongs to the target assignment
1752        is set to its target value.
1753
1754        |
1755
1756        *Overload 2:*
1757        Creates a local search operator that tries to move the assignment of some
1758        variables toward a target. The target is given either as two vectors: a
1759        vector of variables and a vector of associated target values. The two
1760        vectors should be of the same length. This operator generates neighbors in
1761        which the only difference compared to the current state is that one
1762        variable that belongs to the given vector is set to its target value.
1763        """
1764        return _pywrapcp.Solver_MoveTowardTargetOperator(self, *args)
1765
1766    def ConcatenateOperators(self, *args):
1767        return _pywrapcp.Solver_ConcatenateOperators(self, *args)
1768
1769    def RandomConcatenateOperators(self, *args):
1770        r"""
1771        *Overload 1:*
1772        Randomized version of local search concatenator; calls a random operator
1773        at each call to MakeNextNeighbor().
1774
1775        |
1776
1777        *Overload 2:*
1778        Randomized version of local search concatenator; calls a random operator
1779        at each call to MakeNextNeighbor(). The provided seed is used to
1780        initialize the random number generator.
1781        """
1782        return _pywrapcp.Solver_RandomConcatenateOperators(self, *args)
1783
1784    def NeighborhoodLimit(self, op, limit):
1785        r"""
1786        Creates a local search operator that wraps another local search
1787        operator and limits the number of neighbors explored (i.e., calls
1788        to MakeNextNeighbor from the current solution (between two calls
1789        to Start()). When this limit is reached, MakeNextNeighbor()
1790        returns false. The counter is cleared when Start() is called.
1791        """
1792        return _pywrapcp.Solver_NeighborhoodLimit(self, op, limit)
1793
1794    def LocalSearchPhase(self, *args):
1795        return _pywrapcp.Solver_LocalSearchPhase(self, *args)
1796
1797    def LocalSearchPhaseParameters(self, *args):
1798        return _pywrapcp.Solver_LocalSearchPhaseParameters(self, *args)
1799
1800    def TopProgressPercent(self):
1801        r"""
1802        Returns a percentage representing the propress of the search before
1803        reaching the limits of the top-level search (can be called from a nested
1804        solve).
1805        """
1806        return _pywrapcp.Solver_TopProgressPercent(self)
1807
1808    def SearchDepth(self):
1809        r"""
1810        Gets the search depth of the current active search. Returns -1 if
1811        there is no active search opened.
1812        """
1813        return _pywrapcp.Solver_SearchDepth(self)
1814
1815    def SearchLeftDepth(self):
1816        r"""
1817        Gets the search left depth of the current active search. Returns -1 if
1818        there is no active search opened.
1819        """
1820        return _pywrapcp.Solver_SearchLeftDepth(self)
1821
1822    def SolveDepth(self):
1823        r"""
1824        Gets the number of nested searches. It returns 0 outside search,
1825        1 during the top level search, 2 or more in case of nested searches.
1826        """
1827        return _pywrapcp.Solver_SolveDepth(self)
1828
1829    def Rand64(self, size):
1830        r""" Returns a random value between 0 and 'size' - 1;"""
1831        return _pywrapcp.Solver_Rand64(self, size)
1832
1833    def Rand32(self, size):
1834        r""" Returns a random value between 0 and 'size' - 1;"""
1835        return _pywrapcp.Solver_Rand32(self, size)
1836
1837    def ReSeed(self, seed):
1838        r""" Reseed the solver random generator."""
1839        return _pywrapcp.Solver_ReSeed(self, seed)
1840
1841    def LocalSearchProfile(self):
1842        r""" Returns local search profiling information in a human readable format."""
1843        return _pywrapcp.Solver_LocalSearchProfile(self)
1844
1845    def Constraints(self):
1846        r"""
1847        Counts the number of constraints that have been added
1848        to the solver before the search.
1849        """
1850        return _pywrapcp.Solver_Constraints(self)
1851
1852    def Accept(self, visitor):
1853        r""" Accepts the given model visitor."""
1854        return _pywrapcp.Solver_Accept(self, visitor)
1855
1856    def FinishCurrentSearch(self):
1857        r""" Tells the solver to kill or restart the current search."""
1858        return _pywrapcp.Solver_FinishCurrentSearch(self)
1859
1860    def RestartCurrentSearch(self):
1861        return _pywrapcp.Solver_RestartCurrentSearch(self)
1862
1863    def ShouldFail(self):
1864        r"""
1865        These methods are only useful for the SWIG wrappers, which need a way
1866        to externally cause the Solver to fail.
1867        """
1868        return _pywrapcp.Solver_ShouldFail(self)
1869
1870    def __str__(self):
1871        return _pywrapcp.Solver___str__(self)
1872
1873    def Add(self, ct):
1874      if isinstance(ct, PyConstraint):
1875        self.__python_constraints.append(ct)
1876      self.AddConstraint(ct)
1877
1878
1879    def TreeNoCycle(self, nexts, active, callback=0):
1880        return _pywrapcp.Solver_TreeNoCycle(self, nexts, active, callback)
1881
1882    def SearchLogWithCallback(self, period, callback):
1883        return _pywrapcp.Solver_SearchLogWithCallback(self, period, callback)
1884
1885    def ElementFunction(self, values, index):
1886        return _pywrapcp.Solver_ElementFunction(self, values, index)
1887
1888    def VarEvalValStrPhase(self, vars, var_evaluator, val_str):
1889        return _pywrapcp.Solver_VarEvalValStrPhase(self, vars, var_evaluator, val_str)
1890
1891    def VarStrValEvalPhase(self, vars, var_str, val_eval):
1892        return _pywrapcp.Solver_VarStrValEvalPhase(self, vars, var_str, val_eval)
1893
1894    def VarEvalValEvalPhase(self, vars, var_eval, val_eval):
1895        return _pywrapcp.Solver_VarEvalValEvalPhase(self, vars, var_eval, val_eval)
1896
1897    def VarStrValEvalTieBreakPhase(self, vars, var_str, val_eval, tie_breaker):
1898        return _pywrapcp.Solver_VarStrValEvalTieBreakPhase(self, vars, var_str, val_eval, tie_breaker)
1899
1900    def VarEvalValEvalTieBreakPhase(self, vars, var_eval, val_eval, tie_breaker):
1901        return _pywrapcp.Solver_VarEvalValEvalTieBreakPhase(self, vars, var_eval, val_eval, tie_breaker)
1902
1903    def EvalEvalStrPhase(self, vars, evaluator, str):
1904        return _pywrapcp.Solver_EvalEvalStrPhase(self, vars, evaluator, str)
1905
1906    def EvalEvalStrTieBreakPhase(self, vars, evaluator, tie_breaker, str):
1907        return _pywrapcp.Solver_EvalEvalStrTieBreakPhase(self, vars, evaluator, tie_breaker, str)
1908
1909    def GuidedLocalSearch(self, *args):
1910        return _pywrapcp.Solver_GuidedLocalSearch(self, *args)
1911
1912    def SumObjectiveFilter(self, vars, values, filter_enum):
1913        return _pywrapcp.Solver_SumObjectiveFilter(self, vars, values, filter_enum)
1914
1915# Register Solver in _pywrapcp:
1916_pywrapcp.Solver_swigregister(Solver)
1917class BaseObject(object):
1918    r"""
1919    A BaseObject is the root of all reversibly allocated objects.
1920    A DebugString method and the associated << operator are implemented
1921    as a convenience.
1922    """
1923
1924    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1925
1926    def __init__(self):
1927        if self.__class__ == BaseObject:
1928            _self = None
1929        else:
1930            _self = self
1931        _pywrapcp.BaseObject_swiginit(self, _pywrapcp.new_BaseObject(_self, ))
1932    __swig_destroy__ = _pywrapcp.delete_BaseObject
1933
1934    def DebugString(self):
1935        return _pywrapcp.BaseObject_DebugString(self)
1936
1937    def __str__(self):
1938        return _pywrapcp.BaseObject___str__(self)
1939
1940    def __repr__(self):
1941        return _pywrapcp.BaseObject___repr__(self)
1942    def __disown__(self):
1943        self.this.disown()
1944        _pywrapcp.disown_BaseObject(self)
1945        return weakref.proxy(self)
1946
1947# Register BaseObject in _pywrapcp:
1948_pywrapcp.BaseObject_swigregister(BaseObject)
1949class PropagationBaseObject(BaseObject):
1950    r"""
1951    NOLINT
1952    The PropagationBaseObject is a subclass of BaseObject that is also
1953    friend to the Solver class. It allows accessing methods useful when
1954    writing new constraints or new expressions.
1955    """
1956
1957    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1958    __repr__ = _swig_repr
1959
1960    def __init__(self, s):
1961        if self.__class__ == PropagationBaseObject:
1962            _self = None
1963        else:
1964            _self = self
1965        _pywrapcp.PropagationBaseObject_swiginit(self, _pywrapcp.new_PropagationBaseObject(_self, s))
1966    __swig_destroy__ = _pywrapcp.delete_PropagationBaseObject
1967
1968    def DebugString(self):
1969        return _pywrapcp.PropagationBaseObject_DebugString(self)
1970
1971    def solver(self):
1972        return _pywrapcp.PropagationBaseObject_solver(self)
1973
1974    def Name(self):
1975        r""" Object naming."""
1976        return _pywrapcp.PropagationBaseObject_Name(self)
1977    def __disown__(self):
1978        self.this.disown()
1979        _pywrapcp.disown_PropagationBaseObject(self)
1980        return weakref.proxy(self)
1981
1982# Register PropagationBaseObject in _pywrapcp:
1983_pywrapcp.PropagationBaseObject_swigregister(PropagationBaseObject)
1984class Decision(BaseObject):
1985    r"""
1986    A Decision represents a choice point in the search tree. The two main
1987    methods are Apply() to go left, or Refute() to go right.
1988    """
1989
1990    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1991
1992    def __init__(self):
1993        if self.__class__ == Decision:
1994            _self = None
1995        else:
1996            _self = self
1997        _pywrapcp.Decision_swiginit(self, _pywrapcp.new_Decision(_self, ))
1998    __swig_destroy__ = _pywrapcp.delete_Decision
1999
2000    def ApplyWrapper(self, s):
2001        r""" Apply will be called first when the decision is executed."""
2002        return _pywrapcp.Decision_ApplyWrapper(self, s)
2003
2004    def RefuteWrapper(self, s):
2005        r""" Refute will be called after a backtrack."""
2006        return _pywrapcp.Decision_RefuteWrapper(self, s)
2007
2008    def DebugString(self):
2009        return _pywrapcp.Decision_DebugString(self)
2010
2011    def __repr__(self):
2012        return _pywrapcp.Decision___repr__(self)
2013
2014    def __str__(self):
2015        return _pywrapcp.Decision___str__(self)
2016    def __disown__(self):
2017        self.this.disown()
2018        _pywrapcp.disown_Decision(self)
2019        return weakref.proxy(self)
2020
2021# Register Decision in _pywrapcp:
2022_pywrapcp.Decision_swigregister(Decision)
2023class DecisionBuilder(BaseObject):
2024    r"""
2025    A DecisionBuilder is responsible for creating the search tree. The
2026    important method is Next(), which returns the next decision to execute.
2027    """
2028
2029    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2030
2031    def __init__(self):
2032        if self.__class__ == DecisionBuilder:
2033            _self = None
2034        else:
2035            _self = self
2036        _pywrapcp.DecisionBuilder_swiginit(self, _pywrapcp.new_DecisionBuilder(_self, ))
2037    __swig_destroy__ = _pywrapcp.delete_DecisionBuilder
2038
2039    def NextWrapper(self, s):
2040        r"""
2041        This is the main method of the decision builder class. It must
2042        return a decision (an instance of the class Decision). If it
2043        returns nullptr, this means that the decision builder has finished
2044        its work.
2045        """
2046        return _pywrapcp.DecisionBuilder_NextWrapper(self, s)
2047
2048    def DebugString(self):
2049        return _pywrapcp.DecisionBuilder_DebugString(self)
2050
2051    def __repr__(self):
2052        return _pywrapcp.DecisionBuilder___repr__(self)
2053
2054    def __str__(self):
2055        return _pywrapcp.DecisionBuilder___str__(self)
2056    def __disown__(self):
2057        self.this.disown()
2058        _pywrapcp.disown_DecisionBuilder(self)
2059        return weakref.proxy(self)
2060
2061# Register DecisionBuilder in _pywrapcp:
2062_pywrapcp.DecisionBuilder_swigregister(DecisionBuilder)
2063class Demon(BaseObject):
2064    r"""
2065    A Demon is the base element of a propagation queue. It is the main
2066      object responsible for implementing the actual propagation
2067      of the constraint and pruning the inconsistent values in the domains
2068      of the variables. The main concept is that demons are listeners that are
2069      attached to the variables and listen to their modifications.
2070    There are two methods:
2071     - Run() is the actual method called when the demon is processed.
2072     - priority() returns its priority. Standard priorities are slow, normal
2073       or fast. "immediate" is reserved for variables and is treated separately.
2074    """
2075
2076    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2077    __repr__ = _swig_repr
2078
2079    def __init__(self):
2080        r"""
2081        This indicates the priority of a demon. Immediate demons are treated
2082        separately and corresponds to variables.
2083        """
2084        if self.__class__ == Demon:
2085            _self = None
2086        else:
2087            _self = self
2088        _pywrapcp.Demon_swiginit(self, _pywrapcp.new_Demon(_self, ))
2089    __swig_destroy__ = _pywrapcp.delete_Demon
2090
2091    def RunWrapper(self, s):
2092        r""" This is the main callback of the demon."""
2093        return _pywrapcp.Demon_RunWrapper(self, s)
2094
2095    def Priority(self):
2096        r"""
2097        This method returns the priority of the demon. Usually a demon is
2098        fast, slow or normal. Immediate demons are reserved for internal
2099        use to maintain variables.
2100        """
2101        return _pywrapcp.Demon_Priority(self)
2102
2103    def DebugString(self):
2104        return _pywrapcp.Demon_DebugString(self)
2105
2106    def Inhibit(self, s):
2107        r"""
2108        This method inhibits the demon in the search tree below the
2109        current position.
2110        """
2111        return _pywrapcp.Demon_Inhibit(self, s)
2112
2113    def Desinhibit(self, s):
2114        r""" This method un-inhibits the demon that was previously inhibited."""
2115        return _pywrapcp.Demon_Desinhibit(self, s)
2116    def __disown__(self):
2117        self.this.disown()
2118        _pywrapcp.disown_Demon(self)
2119        return weakref.proxy(self)
2120
2121# Register Demon in _pywrapcp:
2122_pywrapcp.Demon_swigregister(Demon)
2123class Constraint(PropagationBaseObject):
2124    r"""
2125    A constraint is the main modeling object. It provides two methods:
2126      - Post() is responsible for creating the demons and attaching them to
2127        immediate demons().
2128      - InitialPropagate() is called once just after Post and performs
2129        the initial propagation. The subsequent propagations will be performed
2130        by the demons Posted during the post() method.
2131    """
2132
2133    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2134
2135    def __init__(self, solver):
2136        if self.__class__ == Constraint:
2137            _self = None
2138        else:
2139            _self = self
2140        _pywrapcp.Constraint_swiginit(self, _pywrapcp.new_Constraint(_self, solver))
2141    __swig_destroy__ = _pywrapcp.delete_Constraint
2142
2143    def Post(self):
2144        r"""
2145        This method is called when the constraint is processed by the
2146        solver. Its main usage is to attach demons to variables.
2147        """
2148        return _pywrapcp.Constraint_Post(self)
2149
2150    def InitialPropagateWrapper(self):
2151        r"""
2152        This method performs the initial propagation of the
2153        constraint. It is called just after the post.
2154        """
2155        return _pywrapcp.Constraint_InitialPropagateWrapper(self)
2156
2157    def DebugString(self):
2158        return _pywrapcp.Constraint_DebugString(self)
2159
2160    def Var(self):
2161        r"""
2162        Creates a Boolean variable representing the status of the constraint
2163        (false = constraint is violated, true = constraint is satisfied). It
2164        returns nullptr if the constraint does not support this API.
2165        """
2166        return _pywrapcp.Constraint_Var(self)
2167
2168    def __repr__(self):
2169        return _pywrapcp.Constraint___repr__(self)
2170
2171    def __str__(self):
2172        return _pywrapcp.Constraint___str__(self)
2173
2174    def __add__(self, *args):
2175        return _pywrapcp.Constraint___add__(self, *args)
2176
2177    def __radd__(self, v):
2178        return _pywrapcp.Constraint___radd__(self, v)
2179
2180    def __sub__(self, *args):
2181        return _pywrapcp.Constraint___sub__(self, *args)
2182
2183    def __rsub__(self, v):
2184        return _pywrapcp.Constraint___rsub__(self, v)
2185
2186    def __mul__(self, *args):
2187        return _pywrapcp.Constraint___mul__(self, *args)
2188
2189    def __rmul__(self, v):
2190        return _pywrapcp.Constraint___rmul__(self, v)
2191
2192    def __floordiv__(self, v):
2193        return _pywrapcp.Constraint___floordiv__(self, v)
2194
2195    def __neg__(self):
2196        return _pywrapcp.Constraint___neg__(self)
2197
2198    def __abs__(self):
2199        return _pywrapcp.Constraint___abs__(self)
2200
2201    def Square(self):
2202        return _pywrapcp.Constraint_Square(self)
2203
2204    def __eq__(self, *args):
2205        return _pywrapcp.Constraint___eq__(self, *args)
2206
2207    def __ne__(self, *args):
2208        return _pywrapcp.Constraint___ne__(self, *args)
2209
2210    def __ge__(self, *args):
2211        return _pywrapcp.Constraint___ge__(self, *args)
2212
2213    def __gt__(self, *args):
2214        return _pywrapcp.Constraint___gt__(self, *args)
2215
2216    def __le__(self, *args):
2217        return _pywrapcp.Constraint___le__(self, *args)
2218
2219    def __lt__(self, *args):
2220        return _pywrapcp.Constraint___lt__(self, *args)
2221
2222    def MapTo(self, vars):
2223        return _pywrapcp.Constraint_MapTo(self, vars)
2224
2225    def IndexOf(self, *args):
2226        return _pywrapcp.Constraint_IndexOf(self, *args)
2227    def __disown__(self):
2228        self.this.disown()
2229        _pywrapcp.disown_Constraint(self)
2230        return weakref.proxy(self)
2231
2232# Register Constraint in _pywrapcp:
2233_pywrapcp.Constraint_swigregister(Constraint)
2234class SearchMonitor(BaseObject):
2235    r""" A search monitor is a simple set of callbacks to monitor all search events"""
2236
2237    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2238    kNoProgress = _pywrapcp.SearchMonitor_kNoProgress
2239
2240    def __init__(self, s):
2241        if self.__class__ == SearchMonitor:
2242            _self = None
2243        else:
2244            _self = self
2245        _pywrapcp.SearchMonitor_swiginit(self, _pywrapcp.new_SearchMonitor(_self, s))
2246    __swig_destroy__ = _pywrapcp.delete_SearchMonitor
2247
2248    def EnterSearch(self):
2249        r""" Beginning of the search."""
2250        return _pywrapcp.SearchMonitor_EnterSearch(self)
2251
2252    def RestartSearch(self):
2253        r""" Restart the search."""
2254        return _pywrapcp.SearchMonitor_RestartSearch(self)
2255
2256    def ExitSearch(self):
2257        r""" End of the search."""
2258        return _pywrapcp.SearchMonitor_ExitSearch(self)
2259
2260    def BeginNextDecision(self, b):
2261        r""" Before calling DecisionBuilder::Next."""
2262        return _pywrapcp.SearchMonitor_BeginNextDecision(self, b)
2263
2264    def EndNextDecision(self, b, d):
2265        r""" After calling DecisionBuilder::Next, along with the returned decision."""
2266        return _pywrapcp.SearchMonitor_EndNextDecision(self, b, d)
2267
2268    def ApplyDecision(self, d):
2269        r""" Before applying the decision."""
2270        return _pywrapcp.SearchMonitor_ApplyDecision(self, d)
2271
2272    def RefuteDecision(self, d):
2273        r""" Before refuting the decision."""
2274        return _pywrapcp.SearchMonitor_RefuteDecision(self, d)
2275
2276    def AfterDecision(self, d, apply):
2277        r"""
2278        Just after refuting or applying the decision, apply is true after Apply.
2279        This is called only if the Apply() or Refute() methods have not failed.
2280        """
2281        return _pywrapcp.SearchMonitor_AfterDecision(self, d, apply)
2282
2283    def BeginFail(self):
2284        r""" Just when the failure occurs."""
2285        return _pywrapcp.SearchMonitor_BeginFail(self)
2286
2287    def EndFail(self):
2288        r""" After completing the backtrack."""
2289        return _pywrapcp.SearchMonitor_EndFail(self)
2290
2291    def BeginInitialPropagation(self):
2292        r""" Before the initial propagation."""
2293        return _pywrapcp.SearchMonitor_BeginInitialPropagation(self)
2294
2295    def EndInitialPropagation(self):
2296        r""" After the initial propagation."""
2297        return _pywrapcp.SearchMonitor_EndInitialPropagation(self)
2298
2299    def AcceptSolution(self):
2300        r"""
2301        This method is called when a solution is found. It asserts whether the
2302        solution is valid. A value of false indicates that the solution
2303        should be discarded.
2304        """
2305        return _pywrapcp.SearchMonitor_AcceptSolution(self)
2306
2307    def AtSolution(self):
2308        r"""
2309        This method is called when a valid solution is found. If the
2310        return value is true, then search will resume after. If the result
2311        is false, then search will stop there.
2312        """
2313        return _pywrapcp.SearchMonitor_AtSolution(self)
2314
2315    def NoMoreSolutions(self):
2316        r""" When the search tree is finished."""
2317        return _pywrapcp.SearchMonitor_NoMoreSolutions(self)
2318
2319    def LocalOptimum(self):
2320        r"""
2321        When a local optimum is reached. If 'true' is returned, the last solution
2322        is discarded and the search proceeds with the next one.
2323        """
2324        return _pywrapcp.SearchMonitor_LocalOptimum(self)
2325
2326    def AcceptDelta(self, delta, deltadelta):
2327        
2328        return _pywrapcp.SearchMonitor_AcceptDelta(self, delta, deltadelta)
2329
2330    def AcceptNeighbor(self):
2331        r""" After accepting a neighbor during local search."""
2332        return _pywrapcp.SearchMonitor_AcceptNeighbor(self)
2333
2334    def ProgressPercent(self):
2335        r"""
2336        Returns a percentage representing the propress of the search before
2337        reaching limits.
2338        """
2339        return _pywrapcp.SearchMonitor_ProgressPercent(self)
2340
2341    def solver(self):
2342        return _pywrapcp.SearchMonitor_solver(self)
2343
2344    def __repr__(self):
2345        return _pywrapcp.SearchMonitor___repr__(self)
2346
2347    def __str__(self):
2348        return _pywrapcp.SearchMonitor___str__(self)
2349    def __disown__(self):
2350        self.this.disown()
2351        _pywrapcp.disown_SearchMonitor(self)
2352        return weakref.proxy(self)
2353
2354# Register SearchMonitor in _pywrapcp:
2355_pywrapcp.SearchMonitor_swigregister(SearchMonitor)
2356class IntExpr(PropagationBaseObject):
2357    r"""
2358    The class IntExpr is the base of all integer expressions in
2359    constraint programming.
2360    It contains the basic protocol for an expression:
2361      - setting and modifying its bound
2362      - querying if it is bound
2363      - listening to events modifying its bounds
2364      - casting it into a variable (instance of IntVar)
2365    """
2366
2367    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2368
2369    def __init__(self, *args, **kwargs):
2370        raise AttributeError("No constructor defined - class is abstract")
2371
2372    def Min(self):
2373        return _pywrapcp.IntExpr_Min(self)
2374
2375    def SetMin(self, m):
2376        return _pywrapcp.IntExpr_SetMin(self, m)
2377
2378    def Max(self):
2379        return _pywrapcp.IntExpr_Max(self)
2380
2381    def SetMax(self, m):
2382        return _pywrapcp.IntExpr_SetMax(self, m)
2383
2384    def SetRange(self, l, u):
2385        r""" This method sets both the min and the max of the expression."""
2386        return _pywrapcp.IntExpr_SetRange(self, l, u)
2387
2388    def SetValue(self, v):
2389        r""" This method sets the value of the expression."""
2390        return _pywrapcp.IntExpr_SetValue(self, v)
2391
2392    def Bound(self):
2393        r""" Returns true if the min and the max of the expression are equal."""
2394        return _pywrapcp.IntExpr_Bound(self)
2395
2396    def IsVar(self):
2397        r""" Returns true if the expression is indeed a variable."""
2398        return _pywrapcp.IntExpr_IsVar(self)
2399
2400    def Var(self):
2401        r""" Creates a variable from the expression."""
2402        return _pywrapcp.IntExpr_Var(self)
2403
2404    def VarWithName(self, name):
2405        r"""
2406        Creates a variable from the expression and set the name of the
2407        resulting var. If the expression is already a variable, then it
2408        will set the name of the expression, possibly overwriting it.
2409        This is just a shortcut to Var() followed by set_name().
2410        """
2411        return _pywrapcp.IntExpr_VarWithName(self, name)
2412
2413    def WhenRange(self, *args):
2414        r"""
2415        *Overload 1:*
2416        Attach a demon that will watch the min or the max of the expression.
2417
2418        |
2419
2420        *Overload 2:*
2421        Attach a demon that will watch the min or the max of the expression.
2422        """
2423        return _pywrapcp.IntExpr_WhenRange(self, *args)
2424
2425    def __repr__(self):
2426        return _pywrapcp.IntExpr___repr__(self)
2427
2428    def __str__(self):
2429        return _pywrapcp.IntExpr___str__(self)
2430
2431    def __add__(self, *args):
2432        return _pywrapcp.IntExpr___add__(self, *args)
2433
2434    def __radd__(self, v):
2435        return _pywrapcp.IntExpr___radd__(self, v)
2436
2437    def __sub__(self, *args):
2438        return _pywrapcp.IntExpr___sub__(self, *args)
2439
2440    def __rsub__(self, v):
2441        return _pywrapcp.IntExpr___rsub__(self, v)
2442
2443    def __mul__(self, *args):
2444        return _pywrapcp.IntExpr___mul__(self, *args)
2445
2446    def __rmul__(self, v):
2447        return _pywrapcp.IntExpr___rmul__(self, v)
2448
2449    def __floordiv__(self, *args):
2450        return _pywrapcp.IntExpr___floordiv__(self, *args)
2451
2452    def __mod__(self, *args):
2453        return _pywrapcp.IntExpr___mod__(self, *args)
2454
2455    def __neg__(self):
2456        return _pywrapcp.IntExpr___neg__(self)
2457
2458    def __abs__(self):
2459        return _pywrapcp.IntExpr___abs__(self)
2460
2461    def Square(self):
2462        return _pywrapcp.IntExpr_Square(self)
2463
2464    def __eq__(self, *args):
2465        return _pywrapcp.IntExpr___eq__(self, *args)
2466
2467    def __ne__(self, *args):
2468        return _pywrapcp.IntExpr___ne__(self, *args)
2469
2470    def __ge__(self, *args):
2471        return _pywrapcp.IntExpr___ge__(self, *args)
2472
2473    def __gt__(self, *args):
2474        return _pywrapcp.IntExpr___gt__(self, *args)
2475
2476    def __le__(self, *args):
2477        return _pywrapcp.IntExpr___le__(self, *args)
2478
2479    def __lt__(self, *args):
2480        return _pywrapcp.IntExpr___lt__(self, *args)
2481
2482    def MapTo(self, vars):
2483        return _pywrapcp.IntExpr_MapTo(self, vars)
2484
2485    def IndexOf(self, *args):
2486        return _pywrapcp.IntExpr_IndexOf(self, *args)
2487
2488    def IsMember(self, values):
2489        return _pywrapcp.IntExpr_IsMember(self, values)
2490
2491    def Member(self, values):
2492        return _pywrapcp.IntExpr_Member(self, values)
2493
2494    def NotMember(self, starts, ends):
2495        return _pywrapcp.IntExpr_NotMember(self, starts, ends)
2496
2497# Register IntExpr in _pywrapcp:
2498_pywrapcp.IntExpr_swigregister(IntExpr)
2499class IntVarIterator(BaseObject):
2500    r"""
2501     The class Iterator has two direct subclasses. HoleIterators
2502     iterates over all holes, that is value removed between the
2503     current min and max of the variable since the last time the
2504     variable was processed in the queue. DomainIterators iterates
2505     over all elements of the variable domain. Both iterators are not
2506     robust to domain changes. Hole iterators can also report values outside
2507     the current min and max of the variable.
2508     HoleIterators should only be called from a demon attached to the
2509     variable that has created this iterator.
2510     IntVar* current_var;
2511     std::unique_ptr<IntVarIterator> it(current_var->MakeHoleIterator(false));
2512     for (const int64_t hole : InitAndGetValues(it)) {
2513    use the hole
2514     }
2515    """
2516
2517    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2518
2519    def __init__(self, *args, **kwargs):
2520        raise AttributeError("No constructor defined - class is abstract")
2521    __repr__ = _swig_repr
2522
2523    def Init(self):
2524        r""" This method must be called before each loop."""
2525        return _pywrapcp.IntVarIterator_Init(self)
2526
2527    def Ok(self):
2528        r""" This method indicates if we can call Value() or not."""
2529        return _pywrapcp.IntVarIterator_Ok(self)
2530
2531    def Value(self):
2532        r""" This method returns the current value of the iterator."""
2533        return _pywrapcp.IntVarIterator_Value(self)
2534
2535    def Next(self):
2536        r""" This method moves the iterator to the next value."""
2537        return _pywrapcp.IntVarIterator_Next(self)
2538
2539    def DebugString(self):
2540        r""" Pretty Print."""
2541        return _pywrapcp.IntVarIterator_DebugString(self)
2542
2543    def __iter__(self):
2544      self.Init()
2545      return self
2546
2547    def next(self):
2548      if self.Ok():
2549        result = self.Value()
2550        self.Next()
2551        return result
2552      else:
2553        raise StopIteration()
2554
2555    def __next__(self):
2556      return self.next()
2557
2558
2559# Register IntVarIterator in _pywrapcp:
2560_pywrapcp.IntVarIterator_swigregister(IntVarIterator)
2561class IntVar(IntExpr):
2562    r"""
2563    The class IntVar is a subset of IntExpr. In addition to the
2564    IntExpr protocol, it offers persistence, removing values from the domains,
2565    and a finer model for events.
2566    """
2567
2568    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2569
2570    def __init__(self, *args, **kwargs):
2571        raise AttributeError("No constructor defined - class is abstract")
2572
2573    def IsVar(self):
2574        return _pywrapcp.IntVar_IsVar(self)
2575
2576    def Var(self):
2577        return _pywrapcp.IntVar_Var(self)
2578
2579    def Value(self):
2580        r"""
2581        This method returns the value of the variable. This method checks
2582        before that the variable is bound.
2583        """
2584        return _pywrapcp.IntVar_Value(self)
2585
2586    def RemoveValue(self, v):
2587        r""" This method removes the value 'v' from the domain of the variable."""
2588        return _pywrapcp.IntVar_RemoveValue(self, v)
2589
2590    def RemoveInterval(self, l, u):
2591        r"""
2592        This method removes the interval 'l' .. 'u' from the domain of
2593        the variable. It assumes that 'l' <= 'u'.
2594        """
2595        return _pywrapcp.IntVar_RemoveInterval(self, l, u)
2596
2597    def RemoveValues(self, values):
2598        r""" This method remove the values from the domain of the variable."""
2599        return _pywrapcp.IntVar_RemoveValues(self, values)
2600
2601    def SetValues(self, values):
2602        r""" This method intersects the current domain with the values in the array."""
2603        return _pywrapcp.IntVar_SetValues(self, values)
2604
2605    def WhenBound(self, *args):
2606        r"""
2607        *Overload 1:*
2608        This method attaches a demon that will be awakened when the
2609        variable is bound.
2610
2611        |
2612
2613        *Overload 2:*
2614        This method attaches a closure that will be awakened when the
2615        variable is bound.
2616        """
2617        return _pywrapcp.IntVar_WhenBound(self, *args)
2618
2619    def WhenDomain(self, *args):
2620        r"""
2621        *Overload 1:*
2622        This method attaches a demon that will watch any domain
2623        modification of the domain of the variable.
2624
2625        |
2626
2627        *Overload 2:*
2628        This method attaches a closure that will watch any domain
2629        modification of the domain of the variable.
2630        """
2631        return _pywrapcp.IntVar_WhenDomain(self, *args)
2632
2633    def Size(self):
2634        r""" This method returns the number of values in the domain of the variable."""
2635        return _pywrapcp.IntVar_Size(self)
2636
2637    def Contains(self, v):
2638        r"""
2639        This method returns whether the value 'v' is in the domain of the
2640        variable.
2641        """
2642        return _pywrapcp.IntVar_Contains(self, v)
2643
2644    def HoleIteratorAux(self, reversible):
2645        r"""
2646        Creates a hole iterator. When 'reversible' is false, the returned
2647        object is created on the normal C++ heap and the solver does NOT
2648        take ownership of the object.
2649        """
2650        return _pywrapcp.IntVar_HoleIteratorAux(self, reversible)
2651
2652    def DomainIteratorAux(self, reversible):
2653        r"""
2654        Creates a domain iterator. When 'reversible' is false, the
2655        returned object is created on the normal C++ heap and the solver
2656        does NOT take ownership of the object.
2657        """
2658        return _pywrapcp.IntVar_DomainIteratorAux(self, reversible)
2659
2660    def OldMin(self):
2661        r""" Returns the previous min."""
2662        return _pywrapcp.IntVar_OldMin(self)
2663
2664    def OldMax(self):
2665        r""" Returns the previous max."""
2666        return _pywrapcp.IntVar_OldMax(self)
2667
2668    def __repr__(self):
2669        return _pywrapcp.IntVar___repr__(self)
2670
2671    def __str__(self):
2672        return _pywrapcp.IntVar___str__(self)
2673
2674    def DomainIterator(self):
2675      return iter(self.DomainIteratorAux(False))
2676
2677    def HoleIterator(self):
2678      return iter(self.HoleIteratorAux(False))
2679
2680
2681# Register IntVar in _pywrapcp:
2682_pywrapcp.IntVar_swigregister(IntVar)
2683class SolutionCollector(SearchMonitor):
2684    r"""
2685    This class is the root class of all solution collectors.
2686    It implements a basic query API to be used independently
2687    of the collector used.
2688    """
2689
2690    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2691
2692    def __init__(self, *args, **kwargs):
2693        raise AttributeError("No constructor defined")
2694    __repr__ = _swig_repr
2695
2696    def DebugString(self):
2697        return _pywrapcp.SolutionCollector_DebugString(self)
2698
2699    def Add(self, *args):
2700        return _pywrapcp.SolutionCollector_Add(self, *args)
2701
2702    def AddObjective(self, objective):
2703        return _pywrapcp.SolutionCollector_AddObjective(self, objective)
2704
2705    def EnterSearch(self):
2706        r""" Beginning of the search."""
2707        return _pywrapcp.SolutionCollector_EnterSearch(self)
2708
2709    def SolutionCount(self):
2710        r""" Returns how many solutions were stored during the search."""
2711        return _pywrapcp.SolutionCollector_SolutionCount(self)
2712
2713    def Solution(self, n):
2714        r""" Returns the nth solution."""
2715        return _pywrapcp.SolutionCollector_Solution(self, n)
2716
2717    def WallTime(self, n):
2718        r""" Returns the wall time in ms for the nth solution."""
2719        return _pywrapcp.SolutionCollector_WallTime(self, n)
2720
2721    def Branches(self, n):
2722        r""" Returns the number of branches when the nth solution was found."""
2723        return _pywrapcp.SolutionCollector_Branches(self, n)
2724
2725    def Failures(self, n):
2726        r"""
2727        Returns the number of failures encountered at the time of the nth
2728        solution.
2729        """
2730        return _pywrapcp.SolutionCollector_Failures(self, n)
2731
2732    def ObjectiveValue(self, n):
2733        r""" Returns the objective value of the nth solution."""
2734        return _pywrapcp.SolutionCollector_ObjectiveValue(self, n)
2735
2736    def Value(self, n, var):
2737        r""" This is a shortcut to get the Value of 'var' in the nth solution."""
2738        return _pywrapcp.SolutionCollector_Value(self, n, var)
2739
2740    def StartValue(self, n, var):
2741        r""" This is a shortcut to get the StartValue of 'var' in the nth solution."""
2742        return _pywrapcp.SolutionCollector_StartValue(self, n, var)
2743
2744    def EndValue(self, n, var):
2745        r""" This is a shortcut to get the EndValue of 'var' in the nth solution."""
2746        return _pywrapcp.SolutionCollector_EndValue(self, n, var)
2747
2748    def DurationValue(self, n, var):
2749        r""" This is a shortcut to get the DurationValue of 'var' in the nth solution."""
2750        return _pywrapcp.SolutionCollector_DurationValue(self, n, var)
2751
2752    def PerformedValue(self, n, var):
2753        r""" This is a shortcut to get the PerformedValue of 'var' in the nth solution."""
2754        return _pywrapcp.SolutionCollector_PerformedValue(self, n, var)
2755
2756    def ForwardSequence(self, n, var):
2757        r"""
2758        This is a shortcut to get the ForwardSequence of 'var' in the
2759        nth solution. The forward sequence is the list of ranked interval
2760        variables starting from the start of the sequence.
2761        """
2762        return _pywrapcp.SolutionCollector_ForwardSequence(self, n, var)
2763
2764    def BackwardSequence(self, n, var):
2765        r"""
2766        This is a shortcut to get the BackwardSequence of 'var' in the
2767        nth solution. The backward sequence is the list of ranked interval
2768        variables starting from the end of the sequence.
2769        """
2770        return _pywrapcp.SolutionCollector_BackwardSequence(self, n, var)
2771
2772    def Unperformed(self, n, var):
2773        r"""
2774        This is a shortcut to get the list of unperformed of 'var' in the
2775        nth solution.
2776        """
2777        return _pywrapcp.SolutionCollector_Unperformed(self, n, var)
2778
2779# Register SolutionCollector in _pywrapcp:
2780_pywrapcp.SolutionCollector_swigregister(SolutionCollector)
2781class OptimizeVar(object):
2782    r"""
2783    This class encapsulates an objective. It requires the direction
2784    (minimize or maximize), the variable to optimize, and the
2785    improvement step.
2786    """
2787
2788    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2789
2790    def __init__(self, *args, **kwargs):
2791        raise AttributeError("No constructor defined")
2792    __repr__ = _swig_repr
2793
2794    def Best(self):
2795        r""" Returns the best value found during search."""
2796        return _pywrapcp.OptimizeVar_Best(self)
2797
2798    def AcceptDelta(self, delta, deltadelta):
2799        r""" Internal methods."""
2800        return _pywrapcp.OptimizeVar_AcceptDelta(self, delta, deltadelta)
2801
2802    def BeginNextDecision(self, db):
2803        return _pywrapcp.OptimizeVar_BeginNextDecision(self, db)
2804
2805    def RefuteDecision(self, d):
2806        return _pywrapcp.OptimizeVar_RefuteDecision(self, d)
2807
2808    def AtSolution(self):
2809        return _pywrapcp.OptimizeVar_AtSolution(self)
2810
2811    def AcceptSolution(self):
2812        return _pywrapcp.OptimizeVar_AcceptSolution(self)
2813
2814    def DebugString(self):
2815        return _pywrapcp.OptimizeVar_DebugString(self)
2816    __swig_destroy__ = _pywrapcp.delete_OptimizeVar
2817
2818# Register OptimizeVar in _pywrapcp:
2819_pywrapcp.OptimizeVar_swigregister(OptimizeVar)
2820class SearchLimit(SearchMonitor):
2821    r""" Base class of all search limits."""
2822
2823    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2824
2825    def __init__(self, *args, **kwargs):
2826        raise AttributeError("No constructor defined - class is abstract")
2827    __repr__ = _swig_repr
2828    __swig_destroy__ = _pywrapcp.delete_SearchLimit
2829
2830    def Crossed(self):
2831        r""" Returns true if the limit has been crossed."""
2832        return _pywrapcp.SearchLimit_Crossed(self)
2833
2834    def Check(self):
2835        r"""
2836        This method is called to check the status of the limit. A return
2837        value of true indicates that we have indeed crossed the limit. In
2838        that case, this method will not be called again and the remaining
2839        search will be discarded.
2840        """
2841        return _pywrapcp.SearchLimit_Check(self)
2842
2843    def Init(self):
2844        r""" This method is called when the search limit is initialized."""
2845        return _pywrapcp.SearchLimit_Init(self)
2846
2847    def EnterSearch(self):
2848        r""" Internal methods."""
2849        return _pywrapcp.SearchLimit_EnterSearch(self)
2850
2851    def BeginNextDecision(self, b):
2852        return _pywrapcp.SearchLimit_BeginNextDecision(self, b)
2853
2854    def RefuteDecision(self, d):
2855        return _pywrapcp.SearchLimit_RefuteDecision(self, d)
2856
2857    def DebugString(self):
2858        return _pywrapcp.SearchLimit_DebugString(self)
2859
2860# Register SearchLimit in _pywrapcp:
2861_pywrapcp.SearchLimit_swigregister(SearchLimit)
2862class IntervalVar(PropagationBaseObject):
2863    r"""
2864    Interval variables are often used in scheduling. The main characteristics
2865    of an IntervalVar are the start position, duration, and end
2866    date. All these characteristics can be queried and set, and demons can
2867    be posted on their modifications.
2868
2869    An important aspect is optionality: an IntervalVar can be performed or not.
2870    If unperformed, then it simply does not exist, and its characteristics
2871    cannot be accessed any more. An interval var is automatically marked
2872    as unperformed when it is not consistent anymore (start greater
2873    than end, duration < 0...)
2874    """
2875
2876    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2877
2878    def __init__(self, *args, **kwargs):
2879        raise AttributeError("No constructor defined - class is abstract")
2880
2881    def StartMin(self):
2882        r"""
2883        These methods query, set, and watch the start position of the
2884        interval var.
2885        """
2886        return _pywrapcp.IntervalVar_StartMin(self)
2887
2888    def StartMax(self):
2889        return _pywrapcp.IntervalVar_StartMax(self)
2890
2891    def SetStartMin(self, m):
2892        return _pywrapcp.IntervalVar_SetStartMin(self, m)
2893
2894    def SetStartMax(self, m):
2895        return _pywrapcp.IntervalVar_SetStartMax(self, m)
2896
2897    def SetStartRange(self, mi, ma):
2898        return _pywrapcp.IntervalVar_SetStartRange(self, mi, ma)
2899
2900    def OldStartMin(self):
2901        return _pywrapcp.IntervalVar_OldStartMin(self)
2902
2903    def OldStartMax(self):
2904        return _pywrapcp.IntervalVar_OldStartMax(self)
2905
2906    def WhenStartRange(self, *args):
2907        return _pywrapcp.IntervalVar_WhenStartRange(self, *args)
2908
2909    def WhenStartBound(self, *args):
2910        return _pywrapcp.IntervalVar_WhenStartBound(self, *args)
2911
2912    def DurationMin(self):
2913        r""" These methods query, set, and watch the duration of the interval var."""
2914        return _pywrapcp.IntervalVar_DurationMin(self)
2915
2916    def DurationMax(self):
2917        return _pywrapcp.IntervalVar_DurationMax(self)
2918
2919    def SetDurationMin(self, m):
2920        return _pywrapcp.IntervalVar_SetDurationMin(self, m)
2921
2922    def SetDurationMax(self, m):
2923        return _pywrapcp.IntervalVar_SetDurationMax(self, m)
2924
2925    def SetDurationRange(self, mi, ma):
2926        return _pywrapcp.IntervalVar_SetDurationRange(self, mi, ma)
2927
2928    def OldDurationMin(self):
2929        return _pywrapcp.IntervalVar_OldDurationMin(self)
2930
2931    def OldDurationMax(self):
2932        return _pywrapcp.IntervalVar_OldDurationMax(self)
2933
2934    def WhenDurationRange(self, *args):
2935        return _pywrapcp.IntervalVar_WhenDurationRange(self, *args)
2936
2937    def WhenDurationBound(self, *args):
2938        return _pywrapcp.IntervalVar_WhenDurationBound(self, *args)
2939
2940    def EndMin(self):
2941        r""" These methods query, set, and watch the end position of the interval var."""
2942        return _pywrapcp.IntervalVar_EndMin(self)
2943
2944    def EndMax(self):
2945        return _pywrapcp.IntervalVar_EndMax(self)
2946
2947    def SetEndMin(self, m):
2948        return _pywrapcp.IntervalVar_SetEndMin(self, m)
2949
2950    def SetEndMax(self, m):
2951        return _pywrapcp.IntervalVar_SetEndMax(self, m)
2952
2953    def SetEndRange(self, mi, ma):
2954        return _pywrapcp.IntervalVar_SetEndRange(self, mi, ma)
2955
2956    def OldEndMin(self):
2957        return _pywrapcp.IntervalVar_OldEndMin(self)
2958
2959    def OldEndMax(self):
2960        return _pywrapcp.IntervalVar_OldEndMax(self)
2961
2962    def WhenEndRange(self, *args):
2963        return _pywrapcp.IntervalVar_WhenEndRange(self, *args)
2964
2965    def WhenEndBound(self, *args):
2966        return _pywrapcp.IntervalVar_WhenEndBound(self, *args)
2967
2968    def MustBePerformed(self):
2969        r"""
2970        These methods query, set, and watch the performed status of the
2971        interval var.
2972        """
2973        return _pywrapcp.IntervalVar_MustBePerformed(self)
2974
2975    def MayBePerformed(self):
2976        return _pywrapcp.IntervalVar_MayBePerformed(self)
2977
2978    def CannotBePerformed(self):
2979        return _pywrapcp.IntervalVar_CannotBePerformed(self)
2980
2981    def IsPerformedBound(self):
2982        return _pywrapcp.IntervalVar_IsPerformedBound(self)
2983
2984    def SetPerformed(self, val):
2985        return _pywrapcp.IntervalVar_SetPerformed(self, val)
2986
2987    def WasPerformedBound(self):
2988        return _pywrapcp.IntervalVar_WasPerformedBound(self)
2989
2990    def WhenPerformedBound(self, *args):
2991        return _pywrapcp.IntervalVar_WhenPerformedBound(self, *args)
2992
2993    def WhenAnything(self, *args):
2994        r"""
2995        *Overload 1:*
2996        Attaches a demon awakened when anything about this interval changes.
2997
2998        |
2999
3000        *Overload 2:*
3001        Attaches a closure awakened when anything about this interval changes.
3002        """
3003        return _pywrapcp.IntervalVar_WhenAnything(self, *args)
3004
3005    def StartExpr(self):
3006        r"""
3007        These methods create expressions encapsulating the start, end
3008        and duration of the interval var. Please note that these must not
3009        be used if the interval var is unperformed.
3010        """
3011        return _pywrapcp.IntervalVar_StartExpr(self)
3012
3013    def DurationExpr(self):
3014        return _pywrapcp.IntervalVar_DurationExpr(self)
3015
3016    def EndExpr(self):
3017        return _pywrapcp.IntervalVar_EndExpr(self)
3018
3019    def PerformedExpr(self):
3020        return _pywrapcp.IntervalVar_PerformedExpr(self)
3021
3022    def SafeStartExpr(self, unperformed_value):
3023        r"""
3024        These methods create expressions encapsulating the start, end
3025        and duration of the interval var. If the interval var is
3026        unperformed, they will return the unperformed_value.
3027        """
3028        return _pywrapcp.IntervalVar_SafeStartExpr(self, unperformed_value)
3029
3030    def SafeDurationExpr(self, unperformed_value):
3031        return _pywrapcp.IntervalVar_SafeDurationExpr(self, unperformed_value)
3032
3033    def SafeEndExpr(self, unperformed_value):
3034        return _pywrapcp.IntervalVar_SafeEndExpr(self, unperformed_value)
3035
3036    def EndsAfterEnd(self, other):
3037        return _pywrapcp.IntervalVar_EndsAfterEnd(self, other)
3038
3039    def EndsAfterEndWithDelay(self, other, delay):
3040        return _pywrapcp.IntervalVar_EndsAfterEndWithDelay(self, other, delay)
3041
3042    def EndsAfterStart(self, other):
3043        return _pywrapcp.IntervalVar_EndsAfterStart(self, other)
3044
3045    def EndsAfterStartWithDelay(self, other, delay):
3046        return _pywrapcp.IntervalVar_EndsAfterStartWithDelay(self, other, delay)
3047
3048    def EndsAtEnd(self, other):
3049        return _pywrapcp.IntervalVar_EndsAtEnd(self, other)
3050
3051    def EndsAtEndWithDelay(self, other, delay):
3052        return _pywrapcp.IntervalVar_EndsAtEndWithDelay(self, other, delay)
3053
3054    def EndsAtStart(self, other):
3055        return _pywrapcp.IntervalVar_EndsAtStart(self, other)
3056
3057    def EndsAtStartWithDelay(self, other, delay):
3058        return _pywrapcp.IntervalVar_EndsAtStartWithDelay(self, other, delay)
3059
3060    def StartsAfterEnd(self, other):
3061        return _pywrapcp.IntervalVar_StartsAfterEnd(self, other)
3062
3063    def StartsAfterEndWithDelay(self, other, delay):
3064        return _pywrapcp.IntervalVar_StartsAfterEndWithDelay(self, other, delay)
3065
3066    def StartsAfterStart(self, other):
3067        return _pywrapcp.IntervalVar_StartsAfterStart(self, other)
3068
3069    def StartsAfterStartWithDelay(self, other, delay):
3070        return _pywrapcp.IntervalVar_StartsAfterStartWithDelay(self, other, delay)
3071
3072    def StartsAtEnd(self, other):
3073        return _pywrapcp.IntervalVar_StartsAtEnd(self, other)
3074
3075    def StartsAtEndWithDelay(self, other, delay):
3076        return _pywrapcp.IntervalVar_StartsAtEndWithDelay(self, other, delay)
3077
3078    def StartsAtStart(self, other):
3079        return _pywrapcp.IntervalVar_StartsAtStart(self, other)
3080
3081    def StartsAtStartWithDelay(self, other, delay):
3082        return _pywrapcp.IntervalVar_StartsAtStartWithDelay(self, other, delay)
3083
3084    def StaysInSync(self, other):
3085        return _pywrapcp.IntervalVar_StaysInSync(self, other)
3086
3087    def StaysInSyncWithDelay(self, other, delay):
3088        return _pywrapcp.IntervalVar_StaysInSyncWithDelay(self, other, delay)
3089
3090    def EndsAfter(self, date):
3091        return _pywrapcp.IntervalVar_EndsAfter(self, date)
3092
3093    def EndsAt(self, date):
3094        return _pywrapcp.IntervalVar_EndsAt(self, date)
3095
3096    def EndsBefore(self, date):
3097        return _pywrapcp.IntervalVar_EndsBefore(self, date)
3098
3099    def StartsAfter(self, date):
3100        return _pywrapcp.IntervalVar_StartsAfter(self, date)
3101
3102    def StartsAt(self, date):
3103        return _pywrapcp.IntervalVar_StartsAt(self, date)
3104
3105    def StartsBefore(self, date):
3106        return _pywrapcp.IntervalVar_StartsBefore(self, date)
3107
3108    def CrossesDate(self, date):
3109        return _pywrapcp.IntervalVar_CrossesDate(self, date)
3110
3111    def AvoidsDate(self, date):
3112        return _pywrapcp.IntervalVar_AvoidsDate(self, date)
3113
3114    def __repr__(self):
3115        return _pywrapcp.IntervalVar___repr__(self)
3116
3117    def __str__(self):
3118        return _pywrapcp.IntervalVar___str__(self)
3119
3120# Register IntervalVar in _pywrapcp:
3121_pywrapcp.IntervalVar_swigregister(IntervalVar)
3122class SequenceVar(PropagationBaseObject):
3123    r"""
3124    A sequence variable is a variable whose domain is a set of possible
3125    orderings of the interval variables. It allows ordering of tasks. It
3126    has two sets of methods: ComputePossibleFirstsAndLasts(), which
3127    returns the list of interval variables that can be ranked first or
3128    last; and RankFirst/RankNotFirst/RankLast/RankNotLast, which can be
3129    used to create the search decision.
3130    """
3131
3132    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3133
3134    def __init__(self, *args, **kwargs):
3135        raise AttributeError("No constructor defined")
3136
3137    def DebugString(self):
3138        return _pywrapcp.SequenceVar_DebugString(self)
3139
3140    def RankFirst(self, index):
3141        r"""
3142        Ranks the index_th interval var first of all unranked interval
3143        vars. After that, it will no longer be considered ranked.
3144        """
3145        return _pywrapcp.SequenceVar_RankFirst(self, index)
3146
3147    def RankNotFirst(self, index):
3148        r"""
3149        Indicates that the index_th interval var will not be ranked first
3150        of all currently unranked interval vars.
3151        """
3152        return _pywrapcp.SequenceVar_RankNotFirst(self, index)
3153
3154    def RankLast(self, index):
3155        r"""
3156        Ranks the index_th interval var first of all unranked interval
3157        vars. After that, it will no longer be considered ranked.
3158        """
3159        return _pywrapcp.SequenceVar_RankLast(self, index)
3160
3161    def RankNotLast(self, index):
3162        r"""
3163        Indicates that the index_th interval var will not be ranked first
3164        of all currently unranked interval vars.
3165        """
3166        return _pywrapcp.SequenceVar_RankNotLast(self, index)
3167
3168    def Interval(self, index):
3169        r""" Returns the index_th interval of the sequence."""
3170        return _pywrapcp.SequenceVar_Interval(self, index)
3171
3172    def Next(self, index):
3173        r""" Returns the next of the index_th interval of the sequence."""
3174        return _pywrapcp.SequenceVar_Next(self, index)
3175
3176    def Size(self):
3177        r""" Returns the number of interval vars in the sequence."""
3178        return _pywrapcp.SequenceVar_Size(self)
3179
3180    def __repr__(self):
3181        return _pywrapcp.SequenceVar___repr__(self)
3182
3183    def __str__(self):
3184        return _pywrapcp.SequenceVar___str__(self)
3185
3186# Register SequenceVar in _pywrapcp:
3187_pywrapcp.SequenceVar_swigregister(SequenceVar)
3188class AssignmentElement(object):
3189    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3190
3191    def __init__(self, *args, **kwargs):
3192        raise AttributeError("No constructor defined")
3193    __repr__ = _swig_repr
3194
3195    def Activate(self):
3196        return _pywrapcp.AssignmentElement_Activate(self)
3197
3198    def Deactivate(self):
3199        return _pywrapcp.AssignmentElement_Deactivate(self)
3200
3201    def Activated(self):
3202        return _pywrapcp.AssignmentElement_Activated(self)
3203    __swig_destroy__ = _pywrapcp.delete_AssignmentElement
3204
3205# Register AssignmentElement in _pywrapcp:
3206_pywrapcp.AssignmentElement_swigregister(AssignmentElement)
3207class IntVarElement(AssignmentElement):
3208    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3209
3210    def __init__(self, *args, **kwargs):
3211        raise AttributeError("No constructor defined")
3212    __repr__ = _swig_repr
3213
3214    def Var(self):
3215        return _pywrapcp.IntVarElement_Var(self)
3216
3217    def Min(self):
3218        return _pywrapcp.IntVarElement_Min(self)
3219
3220    def SetMin(self, m):
3221        return _pywrapcp.IntVarElement_SetMin(self, m)
3222
3223    def Max(self):
3224        return _pywrapcp.IntVarElement_Max(self)
3225
3226    def SetMax(self, m):
3227        return _pywrapcp.IntVarElement_SetMax(self, m)
3228
3229    def Value(self):
3230        return _pywrapcp.IntVarElement_Value(self)
3231
3232    def Bound(self):
3233        return _pywrapcp.IntVarElement_Bound(self)
3234
3235    def SetRange(self, l, u):
3236        return _pywrapcp.IntVarElement_SetRange(self, l, u)
3237
3238    def SetValue(self, v):
3239        return _pywrapcp.IntVarElement_SetValue(self, v)
3240
3241    def __eq__(self, element):
3242        return _pywrapcp.IntVarElement___eq__(self, element)
3243
3244    def __ne__(self, element):
3245        return _pywrapcp.IntVarElement___ne__(self, element)
3246    __swig_destroy__ = _pywrapcp.delete_IntVarElement
3247
3248# Register IntVarElement in _pywrapcp:
3249_pywrapcp.IntVarElement_swigregister(IntVarElement)
3250class IntervalVarElement(AssignmentElement):
3251    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3252
3253    def __init__(self, *args, **kwargs):
3254        raise AttributeError("No constructor defined")
3255    __repr__ = _swig_repr
3256
3257    def Var(self):
3258        return _pywrapcp.IntervalVarElement_Var(self)
3259
3260    def StartMin(self):
3261        return _pywrapcp.IntervalVarElement_StartMin(self)
3262
3263    def StartMax(self):
3264        return _pywrapcp.IntervalVarElement_StartMax(self)
3265
3266    def StartValue(self):
3267        return _pywrapcp.IntervalVarElement_StartValue(self)
3268
3269    def DurationMin(self):
3270        return _pywrapcp.IntervalVarElement_DurationMin(self)
3271
3272    def DurationMax(self):
3273        return _pywrapcp.IntervalVarElement_DurationMax(self)
3274
3275    def DurationValue(self):
3276        return _pywrapcp.IntervalVarElement_DurationValue(self)
3277
3278    def EndMin(self):
3279        return _pywrapcp.IntervalVarElement_EndMin(self)
3280
3281    def EndMax(self):
3282        return _pywrapcp.IntervalVarElement_EndMax(self)
3283
3284    def EndValue(self):
3285        return _pywrapcp.IntervalVarElement_EndValue(self)
3286
3287    def PerformedMin(self):
3288        return _pywrapcp.IntervalVarElement_PerformedMin(self)
3289
3290    def PerformedMax(self):
3291        return _pywrapcp.IntervalVarElement_PerformedMax(self)
3292
3293    def PerformedValue(self):
3294        return _pywrapcp.IntervalVarElement_PerformedValue(self)
3295
3296    def SetStartMin(self, m):
3297        return _pywrapcp.IntervalVarElement_SetStartMin(self, m)
3298
3299    def SetStartMax(self, m):
3300        return _pywrapcp.IntervalVarElement_SetStartMax(self, m)
3301
3302    def SetStartRange(self, mi, ma):
3303        return _pywrapcp.IntervalVarElement_SetStartRange(self, mi, ma)
3304
3305    def SetStartValue(self, v):
3306        return _pywrapcp.IntervalVarElement_SetStartValue(self, v)
3307
3308    def SetDurationMin(self, m):
3309        return _pywrapcp.IntervalVarElement_SetDurationMin(self, m)
3310
3311    def SetDurationMax(self, m):
3312        return _pywrapcp.IntervalVarElement_SetDurationMax(self, m)
3313
3314    def SetDurationRange(self, mi, ma):
3315        return _pywrapcp.IntervalVarElement_SetDurationRange(self, mi, ma)
3316
3317    def SetDurationValue(self, v):
3318        return _pywrapcp.IntervalVarElement_SetDurationValue(self, v)
3319
3320    def SetEndMin(self, m):
3321        return _pywrapcp.IntervalVarElement_SetEndMin(self, m)
3322
3323    def SetEndMax(self, m):
3324        return _pywrapcp.IntervalVarElement_SetEndMax(self, m)
3325
3326    def SetEndRange(self, mi, ma):
3327        return _pywrapcp.IntervalVarElement_SetEndRange(self, mi, ma)
3328
3329    def SetEndValue(self, v):
3330        return _pywrapcp.IntervalVarElement_SetEndValue(self, v)
3331
3332    def SetPerformedMin(self, m):
3333        return _pywrapcp.IntervalVarElement_SetPerformedMin(self, m)
3334
3335    def SetPerformedMax(self, m):
3336        return _pywrapcp.IntervalVarElement_SetPerformedMax(self, m)
3337
3338    def SetPerformedRange(self, mi, ma):
3339        return _pywrapcp.IntervalVarElement_SetPerformedRange(self, mi, ma)
3340
3341    def SetPerformedValue(self, v):
3342        return _pywrapcp.IntervalVarElement_SetPerformedValue(self, v)
3343
3344    def __eq__(self, element):
3345        return _pywrapcp.IntervalVarElement___eq__(self, element)
3346
3347    def __ne__(self, element):
3348        return _pywrapcp.IntervalVarElement___ne__(self, element)
3349    __swig_destroy__ = _pywrapcp.delete_IntervalVarElement
3350
3351# Register IntervalVarElement in _pywrapcp:
3352_pywrapcp.IntervalVarElement_swigregister(IntervalVarElement)
3353class SequenceVarElement(AssignmentElement):
3354    r"""
3355    The SequenceVarElement stores a partial representation of ranked
3356    interval variables in the underlying sequence variable.
3357    This representation consists of three vectors:
3358      - the forward sequence. That is the list of interval variables
3359        ranked first in the sequence.  The first element of the backward
3360        sequence is the first interval in the sequence variable.
3361      - the backward sequence. That is the list of interval variables
3362        ranked last in the sequence. The first element of the backward
3363        sequence is the last interval in the sequence variable.
3364      - The list of unperformed interval variables.
3365     Furthermore, if all performed variables are ranked, then by
3366     convention, the forward_sequence will contain all such variables
3367     and the backward_sequence will be empty.
3368    """
3369
3370    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3371
3372    def __init__(self, *args, **kwargs):
3373        raise AttributeError("No constructor defined")
3374    __repr__ = _swig_repr
3375
3376    def Var(self):
3377        return _pywrapcp.SequenceVarElement_Var(self)
3378
3379    def ForwardSequence(self):
3380        return _pywrapcp.SequenceVarElement_ForwardSequence(self)
3381
3382    def BackwardSequence(self):
3383        return _pywrapcp.SequenceVarElement_BackwardSequence(self)
3384
3385    def Unperformed(self):
3386        return _pywrapcp.SequenceVarElement_Unperformed(self)
3387
3388    def SetSequence(self, forward_sequence, backward_sequence, unperformed):
3389        return _pywrapcp.SequenceVarElement_SetSequence(self, forward_sequence, backward_sequence, unperformed)
3390
3391    def SetForwardSequence(self, forward_sequence):
3392        return _pywrapcp.SequenceVarElement_SetForwardSequence(self, forward_sequence)
3393
3394    def SetBackwardSequence(self, backward_sequence):
3395        return _pywrapcp.SequenceVarElement_SetBackwardSequence(self, backward_sequence)
3396
3397    def SetUnperformed(self, unperformed):
3398        return _pywrapcp.SequenceVarElement_SetUnperformed(self, unperformed)
3399
3400    def __eq__(self, element):
3401        return _pywrapcp.SequenceVarElement___eq__(self, element)
3402
3403    def __ne__(self, element):
3404        return _pywrapcp.SequenceVarElement___ne__(self, element)
3405    __swig_destroy__ = _pywrapcp.delete_SequenceVarElement
3406
3407# Register SequenceVarElement in _pywrapcp:
3408_pywrapcp.SequenceVarElement_swigregister(SequenceVarElement)
3409class Assignment(PropagationBaseObject):
3410    r"""
3411    An Assignment is a variable -> domains mapping, used
3412    to report solutions to the user.
3413    """
3414
3415    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3416
3417    def __init__(self, *args, **kwargs):
3418        raise AttributeError("No constructor defined")
3419    __repr__ = _swig_repr
3420
3421    def Clear(self):
3422        return _pywrapcp.Assignment_Clear(self)
3423
3424    def Empty(self):
3425        return _pywrapcp.Assignment_Empty(self)
3426
3427    def Size(self):
3428        return _pywrapcp.Assignment_Size(self)
3429
3430    def NumIntVars(self):
3431        return _pywrapcp.Assignment_NumIntVars(self)
3432
3433    def NumIntervalVars(self):
3434        return _pywrapcp.Assignment_NumIntervalVars(self)
3435
3436    def NumSequenceVars(self):
3437        return _pywrapcp.Assignment_NumSequenceVars(self)
3438
3439    def Store(self):
3440        return _pywrapcp.Assignment_Store(self)
3441
3442    def Restore(self):
3443        return _pywrapcp.Assignment_Restore(self)
3444
3445    def Load(self, *args):
3446        return _pywrapcp.Assignment_Load(self, *args)
3447
3448    def Save(self, *args):
3449        return _pywrapcp.Assignment_Save(self, *args)
3450
3451    def AddObjective(self, v):
3452        return _pywrapcp.Assignment_AddObjective(self, v)
3453
3454    def Objective(self):
3455        return _pywrapcp.Assignment_Objective(self)
3456
3457    def HasObjective(self):
3458        return _pywrapcp.Assignment_HasObjective(self)
3459
3460    def ObjectiveMin(self):
3461        return _pywrapcp.Assignment_ObjectiveMin(self)
3462
3463    def ObjectiveMax(self):
3464        return _pywrapcp.Assignment_ObjectiveMax(self)
3465
3466    def ObjectiveValue(self):
3467        return _pywrapcp.Assignment_ObjectiveValue(self)
3468
3469    def ObjectiveBound(self):
3470        return _pywrapcp.Assignment_ObjectiveBound(self)
3471
3472    def SetObjectiveMin(self, m):
3473        return _pywrapcp.Assignment_SetObjectiveMin(self, m)
3474
3475    def SetObjectiveMax(self, m):
3476        return _pywrapcp.Assignment_SetObjectiveMax(self, m)
3477
3478    def SetObjectiveValue(self, value):
3479        return _pywrapcp.Assignment_SetObjectiveValue(self, value)
3480
3481    def SetObjectiveRange(self, l, u):
3482        return _pywrapcp.Assignment_SetObjectiveRange(self, l, u)
3483
3484    def Min(self, var):
3485        return _pywrapcp.Assignment_Min(self, var)
3486
3487    def Max(self, var):
3488        return _pywrapcp.Assignment_Max(self, var)
3489
3490    def Value(self, var):
3491        return _pywrapcp.Assignment_Value(self, var)
3492
3493    def Bound(self, var):
3494        return _pywrapcp.Assignment_Bound(self, var)
3495
3496    def SetMin(self, var, m):
3497        return _pywrapcp.Assignment_SetMin(self, var, m)
3498
3499    def SetMax(self, var, m):
3500        return _pywrapcp.Assignment_SetMax(self, var, m)
3501
3502    def SetRange(self, var, l, u):
3503        return _pywrapcp.Assignment_SetRange(self, var, l, u)
3504
3505    def SetValue(self, var, value):
3506        return _pywrapcp.Assignment_SetValue(self, var, value)
3507
3508    def StartMin(self, var):
3509        return _pywrapcp.Assignment_StartMin(self, var)
3510
3511    def StartMax(self, var):
3512        return _pywrapcp.Assignment_StartMax(self, var)
3513
3514    def StartValue(self, var):
3515        return _pywrapcp.Assignment_StartValue(self, var)
3516
3517    def DurationMin(self, var):
3518        return _pywrapcp.Assignment_DurationMin(self, var)
3519
3520    def DurationMax(self, var):
3521        return _pywrapcp.Assignment_DurationMax(self, var)
3522
3523    def DurationValue(self, var):
3524        return _pywrapcp.Assignment_DurationValue(self, var)
3525
3526    def EndMin(self, var):
3527        return _pywrapcp.Assignment_EndMin(self, var)
3528
3529    def EndMax(self, var):
3530        return _pywrapcp.Assignment_EndMax(self, var)
3531
3532    def EndValue(self, var):
3533        return _pywrapcp.Assignment_EndValue(self, var)
3534
3535    def PerformedMin(self, var):
3536        return _pywrapcp.Assignment_PerformedMin(self, var)
3537
3538    def PerformedMax(self, var):
3539        return _pywrapcp.Assignment_PerformedMax(self, var)
3540
3541    def PerformedValue(self, var):
3542        return _pywrapcp.Assignment_PerformedValue(self, var)
3543
3544    def SetStartMin(self, var, m):
3545        return _pywrapcp.Assignment_SetStartMin(self, var, m)
3546
3547    def SetStartMax(self, var, m):
3548        return _pywrapcp.Assignment_SetStartMax(self, var, m)
3549
3550    def SetStartRange(self, var, mi, ma):
3551        return _pywrapcp.Assignment_SetStartRange(self, var, mi, ma)
3552
3553    def SetStartValue(self, var, value):
3554        return _pywrapcp.Assignment_SetStartValue(self, var, value)
3555
3556    def SetDurationMin(self, var, m):
3557        return _pywrapcp.Assignment_SetDurationMin(self, var, m)
3558
3559    def SetDurationMax(self, var, m):
3560        return _pywrapcp.Assignment_SetDurationMax(self, var, m)
3561
3562    def SetDurationRange(self, var, mi, ma):
3563        return _pywrapcp.Assignment_SetDurationRange(self, var, mi, ma)
3564
3565    def SetDurationValue(self, var, value):
3566        return _pywrapcp.Assignment_SetDurationValue(self, var, value)
3567
3568    def SetEndMin(self, var, m):
3569        return _pywrapcp.Assignment_SetEndMin(self, var, m)
3570
3571    def SetEndMax(self, var, m):
3572        return _pywrapcp.Assignment_SetEndMax(self, var, m)
3573
3574    def SetEndRange(self, var, mi, ma):
3575        return _pywrapcp.Assignment_SetEndRange(self, var, mi, ma)
3576
3577    def SetEndValue(self, var, value):
3578        return _pywrapcp.Assignment_SetEndValue(self, var, value)
3579
3580    def SetPerformedMin(self, var, m):
3581        return _pywrapcp.Assignment_SetPerformedMin(self, var, m)
3582
3583    def SetPerformedMax(self, var, m):
3584        return _pywrapcp.Assignment_SetPerformedMax(self, var, m)
3585
3586    def SetPerformedRange(self, var, mi, ma):
3587        return _pywrapcp.Assignment_SetPerformedRange(self, var, mi, ma)
3588
3589    def SetPerformedValue(self, var, value):
3590        return _pywrapcp.Assignment_SetPerformedValue(self, var, value)
3591
3592    def Add(self, *args):
3593        return _pywrapcp.Assignment_Add(self, *args)
3594
3595    def ForwardSequence(self, var):
3596        return _pywrapcp.Assignment_ForwardSequence(self, var)
3597
3598    def BackwardSequence(self, var):
3599        return _pywrapcp.Assignment_BackwardSequence(self, var)
3600
3601    def Unperformed(self, var):
3602        return _pywrapcp.Assignment_Unperformed(self, var)
3603
3604    def SetSequence(self, var, forward_sequence, backward_sequence, unperformed):
3605        return _pywrapcp.Assignment_SetSequence(self, var, forward_sequence, backward_sequence, unperformed)
3606
3607    def SetForwardSequence(self, var, forward_sequence):
3608        return _pywrapcp.Assignment_SetForwardSequence(self, var, forward_sequence)
3609
3610    def SetBackwardSequence(self, var, backward_sequence):
3611        return _pywrapcp.Assignment_SetBackwardSequence(self, var, backward_sequence)
3612
3613    def SetUnperformed(self, var, unperformed):
3614        return _pywrapcp.Assignment_SetUnperformed(self, var, unperformed)
3615
3616    def Activate(self, *args):
3617        return _pywrapcp.Assignment_Activate(self, *args)
3618
3619    def Deactivate(self, *args):
3620        return _pywrapcp.Assignment_Deactivate(self, *args)
3621
3622    def Activated(self, *args):
3623        return _pywrapcp.Assignment_Activated(self, *args)
3624
3625    def DebugString(self):
3626        return _pywrapcp.Assignment_DebugString(self)
3627
3628    def IntVarContainer(self):
3629        return _pywrapcp.Assignment_IntVarContainer(self)
3630
3631    def MutableIntVarContainer(self):
3632        return _pywrapcp.Assignment_MutableIntVarContainer(self)
3633
3634    def IntervalVarContainer(self):
3635        return _pywrapcp.Assignment_IntervalVarContainer(self)
3636
3637    def MutableIntervalVarContainer(self):
3638        return _pywrapcp.Assignment_MutableIntervalVarContainer(self)
3639
3640    def SequenceVarContainer(self):
3641        return _pywrapcp.Assignment_SequenceVarContainer(self)
3642
3643    def MutableSequenceVarContainer(self):
3644        return _pywrapcp.Assignment_MutableSequenceVarContainer(self)
3645
3646    def __eq__(self, assignment):
3647        return _pywrapcp.Assignment___eq__(self, assignment)
3648
3649    def __ne__(self, assignment):
3650        return _pywrapcp.Assignment___ne__(self, assignment)
3651
3652# Register Assignment in _pywrapcp:
3653_pywrapcp.Assignment_swigregister(Assignment)
3654
3655def __lshift__(*args):
3656    return _pywrapcp.__lshift__(*args)
3657class Pack(Constraint):
3658    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3659
3660    def __init__(self, *args, **kwargs):
3661        raise AttributeError("No constructor defined")
3662    __repr__ = _swig_repr
3663
3664    def AddWeightedSumLessOrEqualConstantDimension(self, *args):
3665        r"""
3666        *Overload 1:*
3667        Dimensions are additional constraints than can restrict what is
3668        possible with the pack constraint. It can be used to set capacity
3669        limits, to count objects per bin, to compute unassigned
3670        penalties...
3671        This dimension imposes that for all bins b, the weighted sum
3672        (weights[i]) of all objects i assigned to 'b' is less or equal
3673        'bounds[b]'.
3674
3675        |
3676
3677        *Overload 2:*
3678        This dimension imposes that for all bins b, the weighted sum
3679        (weights->Run(i)) of all objects i assigned to 'b' is less or
3680        equal to 'bounds[b]'. Ownership of the callback is transferred to
3681        the pack constraint.
3682
3683        |
3684
3685        *Overload 3:*
3686        This dimension imposes that for all bins b, the weighted sum
3687        (weights->Run(i, b) of all objects i assigned to 'b' is less or
3688        equal to 'bounds[b]'. Ownership of the callback is transferred to
3689        the pack constraint.
3690        """
3691        return _pywrapcp.Pack_AddWeightedSumLessOrEqualConstantDimension(self, *args)
3692
3693    def AddWeightedSumEqualVarDimension(self, *args):
3694        r"""
3695        *Overload 1:*
3696        This dimension imposes that for all bins b, the weighted sum
3697        (weights[i]) of all objects i assigned to 'b' is equal to loads[b].
3698
3699        |
3700
3701        *Overload 2:*
3702        This dimension imposes that for all bins b, the weighted sum
3703        (weights->Run(i, b)) of all objects i assigned to 'b' is equal to
3704        loads[b].
3705        """
3706        return _pywrapcp.Pack_AddWeightedSumEqualVarDimension(self, *args)
3707
3708    def AddSumVariableWeightsLessOrEqualConstantDimension(self, usage, capacity):
3709        r"""
3710        This dimension imposes:
3711        forall b in bins,
3712           sum (i in items: usage[i] * is_assigned(i, b)) <= capacity[b]
3713        where is_assigned(i, b) is true if and only if item i is assigned
3714        to the bin b.
3715
3716        This can be used to model shapes of items by linking variables of
3717        the same item on parallel dimensions with an allowed assignment
3718        constraint.
3719        """
3720        return _pywrapcp.Pack_AddSumVariableWeightsLessOrEqualConstantDimension(self, usage, capacity)
3721
3722    def AddWeightedSumOfAssignedDimension(self, weights, cost_var):
3723        r"""
3724        This dimension enforces that cost_var == sum of weights[i] for
3725        all objects 'i' assigned to a bin.
3726        """
3727        return _pywrapcp.Pack_AddWeightedSumOfAssignedDimension(self, weights, cost_var)
3728
3729    def AddCountUsedBinDimension(self, count_var):
3730        r"""
3731        This dimension links 'count_var' to the actual number of bins used in the
3732        pack.
3733        """
3734        return _pywrapcp.Pack_AddCountUsedBinDimension(self, count_var)
3735
3736    def AddCountAssignedItemsDimension(self, count_var):
3737        r"""
3738        This dimension links 'count_var' to the actual number of items
3739        assigned to a bin in the pack.
3740        """
3741        return _pywrapcp.Pack_AddCountAssignedItemsDimension(self, count_var)
3742
3743    def Post(self):
3744        return _pywrapcp.Pack_Post(self)
3745
3746    def InitialPropagateWrapper(self):
3747        return _pywrapcp.Pack_InitialPropagateWrapper(self)
3748
3749    def DebugString(self):
3750        return _pywrapcp.Pack_DebugString(self)
3751
3752# Register Pack in _pywrapcp:
3753_pywrapcp.Pack_swigregister(Pack)
3754class DisjunctiveConstraint(Constraint):
3755    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3756
3757    def __init__(self, *args, **kwargs):
3758        raise AttributeError("No constructor defined - class is abstract")
3759    __repr__ = _swig_repr
3760
3761    def SequenceVar(self):
3762        r""" Creates a sequence variable from the constraint."""
3763        return _pywrapcp.DisjunctiveConstraint_SequenceVar(self)
3764
3765    def SetTransitionTime(self, transition_time):
3766        r"""
3767        Add a transition time between intervals.  It forces the distance between
3768        the end of interval a and start of interval b that follows it to be at
3769        least transition_time(a, b). This function must always return
3770        a positive or null value.
3771        """
3772        return _pywrapcp.DisjunctiveConstraint_SetTransitionTime(self, transition_time)
3773
3774    def TransitionTime(self, before_index, after_index):
3775        return _pywrapcp.DisjunctiveConstraint_TransitionTime(self, before_index, after_index)
3776
3777# Register DisjunctiveConstraint in _pywrapcp:
3778_pywrapcp.DisjunctiveConstraint_swigregister(DisjunctiveConstraint)
3779class RevInteger(object):
3780    r"""
3781    This class adds reversibility to a POD type.
3782    It contains the stamp optimization. i.e. the SaveValue call is done
3783    only once per node of the search tree.  Please note that actual
3784    stamps always starts at 1, thus an initial value of 0 will always
3785    trigger the first SaveValue.
3786    """
3787
3788    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3789    __repr__ = _swig_repr
3790
3791    def __init__(self, val):
3792        _pywrapcp.RevInteger_swiginit(self, _pywrapcp.new_RevInteger(val))
3793
3794    def Value(self):
3795        return _pywrapcp.RevInteger_Value(self)
3796
3797    def SetValue(self, s, val):
3798        return _pywrapcp.RevInteger_SetValue(self, s, val)
3799    __swig_destroy__ = _pywrapcp.delete_RevInteger
3800
3801# Register RevInteger in _pywrapcp:
3802_pywrapcp.RevInteger_swigregister(RevInteger)
3803class NumericalRevInteger(RevInteger):
3804    r""" Subclass of Rev<T> which adds numerical operations."""
3805
3806    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3807    __repr__ = _swig_repr
3808
3809    def __init__(self, val):
3810        _pywrapcp.NumericalRevInteger_swiginit(self, _pywrapcp.new_NumericalRevInteger(val))
3811
3812    def Add(self, s, to_add):
3813        return _pywrapcp.NumericalRevInteger_Add(self, s, to_add)
3814
3815    def Incr(self, s):
3816        return _pywrapcp.NumericalRevInteger_Incr(self, s)
3817
3818    def Decr(self, s):
3819        return _pywrapcp.NumericalRevInteger_Decr(self, s)
3820    __swig_destroy__ = _pywrapcp.delete_NumericalRevInteger
3821
3822# Register NumericalRevInteger in _pywrapcp:
3823_pywrapcp.NumericalRevInteger_swigregister(NumericalRevInteger)
3824class RevBool(object):
3825    r"""
3826    This class adds reversibility to a POD type.
3827    It contains the stamp optimization. i.e. the SaveValue call is done
3828    only once per node of the search tree.  Please note that actual
3829    stamps always starts at 1, thus an initial value of 0 will always
3830    trigger the first SaveValue.
3831    """
3832
3833    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3834    __repr__ = _swig_repr
3835
3836    def __init__(self, val):
3837        _pywrapcp.RevBool_swiginit(self, _pywrapcp.new_RevBool(val))
3838
3839    def Value(self):
3840        return _pywrapcp.RevBool_Value(self)
3841
3842    def SetValue(self, s, val):
3843        return _pywrapcp.RevBool_SetValue(self, s, val)
3844    __swig_destroy__ = _pywrapcp.delete_RevBool
3845
3846# Register RevBool in _pywrapcp:
3847_pywrapcp.RevBool_swigregister(RevBool)
3848class IntVarContainer(object):
3849    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3850
3851    def __init__(self, *args, **kwargs):
3852        raise AttributeError("No constructor defined")
3853    __repr__ = _swig_repr
3854
3855    def Contains(self, var):
3856        return _pywrapcp.IntVarContainer_Contains(self, var)
3857
3858    def Element(self, index):
3859        return _pywrapcp.IntVarContainer_Element(self, index)
3860
3861    def Size(self):
3862        return _pywrapcp.IntVarContainer_Size(self)
3863
3864    def Store(self):
3865        return _pywrapcp.IntVarContainer_Store(self)
3866
3867    def Restore(self):
3868        return _pywrapcp.IntVarContainer_Restore(self)
3869
3870    def __eq__(self, container):
3871        r"""
3872        Returns true if this and 'container' both represent the same V* -> E map.
3873        Runs in linear time; requires that the == operator on the type E is well
3874        defined.
3875        """
3876        return _pywrapcp.IntVarContainer___eq__(self, container)
3877
3878    def __ne__(self, container):
3879        return _pywrapcp.IntVarContainer___ne__(self, container)
3880    __swig_destroy__ = _pywrapcp.delete_IntVarContainer
3881
3882# Register IntVarContainer in _pywrapcp:
3883_pywrapcp.IntVarContainer_swigregister(IntVarContainer)
3884class IntervalVarContainer(object):
3885    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3886
3887    def __init__(self, *args, **kwargs):
3888        raise AttributeError("No constructor defined")
3889    __repr__ = _swig_repr
3890
3891    def Contains(self, var):
3892        return _pywrapcp.IntervalVarContainer_Contains(self, var)
3893
3894    def Element(self, index):
3895        return _pywrapcp.IntervalVarContainer_Element(self, index)
3896
3897    def Size(self):
3898        return _pywrapcp.IntervalVarContainer_Size(self)
3899
3900    def Store(self):
3901        return _pywrapcp.IntervalVarContainer_Store(self)
3902
3903    def Restore(self):
3904        return _pywrapcp.IntervalVarContainer_Restore(self)
3905
3906    def __eq__(self, container):
3907        r"""
3908        Returns true if this and 'container' both represent the same V* -> E map.
3909        Runs in linear time; requires that the == operator on the type E is well
3910        defined.
3911        """
3912        return _pywrapcp.IntervalVarContainer___eq__(self, container)
3913
3914    def __ne__(self, container):
3915        return _pywrapcp.IntervalVarContainer___ne__(self, container)
3916    __swig_destroy__ = _pywrapcp.delete_IntervalVarContainer
3917
3918# Register IntervalVarContainer in _pywrapcp:
3919_pywrapcp.IntervalVarContainer_swigregister(IntervalVarContainer)
3920class SequenceVarContainer(object):
3921    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3922
3923    def __init__(self, *args, **kwargs):
3924        raise AttributeError("No constructor defined")
3925    __repr__ = _swig_repr
3926
3927    def Contains(self, var):
3928        return _pywrapcp.SequenceVarContainer_Contains(self, var)
3929
3930    def Element(self, index):
3931        return _pywrapcp.SequenceVarContainer_Element(self, index)
3932
3933    def Size(self):
3934        return _pywrapcp.SequenceVarContainer_Size(self)
3935
3936    def Store(self):
3937        return _pywrapcp.SequenceVarContainer_Store(self)
3938
3939    def Restore(self):
3940        return _pywrapcp.SequenceVarContainer_Restore(self)
3941
3942    def __eq__(self, container):
3943        r"""
3944        Returns true if this and 'container' both represent the same V* -> E map.
3945        Runs in linear time; requires that the == operator on the type E is well
3946        defined.
3947        """
3948        return _pywrapcp.SequenceVarContainer___eq__(self, container)
3949
3950    def __ne__(self, container):
3951        return _pywrapcp.SequenceVarContainer___ne__(self, container)
3952    __swig_destroy__ = _pywrapcp.delete_SequenceVarContainer
3953
3954# Register SequenceVarContainer in _pywrapcp:
3955_pywrapcp.SequenceVarContainer_swigregister(SequenceVarContainer)
3956class LocalSearchOperator(BaseObject):
3957    r"""
3958    The base class for all local search operators.
3959
3960    A local search operator is an object that defines the neighborhood of a
3961    solution. In other words, a neighborhood is the set of solutions which can
3962    be reached from a given solution using an operator.
3963
3964    The behavior of the LocalSearchOperator class is similar to iterators.
3965    The operator is synchronized with an assignment (gives the
3966    current values of the variables); this is done in the Start() method.
3967
3968    Then one can iterate over the neighbors using the MakeNextNeighbor method.
3969    This method returns an assignment which represents the incremental changes
3970    to the current solution. It also returns a second assignment representing
3971    the changes to the last solution defined by the neighborhood operator; this
3972    assignment is empty if the neighborhood operator cannot track this
3973    information.
3974    """
3975
3976    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3977
3978    def __init__(self, *args, **kwargs):
3979        raise AttributeError("No constructor defined - class is abstract")
3980    __repr__ = _swig_repr
3981
3982    def NextNeighbor(self, delta, deltadelta):
3983        return _pywrapcp.LocalSearchOperator_NextNeighbor(self, delta, deltadelta)
3984
3985    def Start(self, assignment):
3986        return _pywrapcp.LocalSearchOperator_Start(self, assignment)
3987    def __disown__(self):
3988        self.this.disown()
3989        _pywrapcp.disown_LocalSearchOperator(self)
3990        return weakref.proxy(self)
3991
3992# Register LocalSearchOperator in _pywrapcp:
3993_pywrapcp.LocalSearchOperator_swigregister(LocalSearchOperator)
3994class IntVarLocalSearchOperator(LocalSearchOperator):
3995    r"""
3996    Specialization of LocalSearchOperator built from an array of IntVars
3997    which specifies the scope of the operator.
3998    This class also takes care of storing current variable values in Start(),
3999    keeps track of changes done by the operator and builds the delta.
4000    The Deactivate() method can be used to perform Large Neighborhood Search.
4001    """
4002
4003    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4004    __repr__ = _swig_repr
4005
4006    def __init__(self, vars, keep_inverse_values=False):
4007        if self.__class__ == IntVarLocalSearchOperator:
4008            _self = None
4009        else:
4010            _self = self
4011        _pywrapcp.IntVarLocalSearchOperator_swiginit(self, _pywrapcp.new_IntVarLocalSearchOperator(_self, vars, keep_inverse_values))
4012    __swig_destroy__ = _pywrapcp.delete_IntVarLocalSearchOperator
4013
4014    def Start(self, assignment):
4015        r"""
4016        This method should not be overridden. Override OnStart() instead which is
4017        called before exiting this method.
4018        """
4019        return _pywrapcp.IntVarLocalSearchOperator_Start(self, assignment)
4020
4021    def IsIncremental(self):
4022        return _pywrapcp.IntVarLocalSearchOperator_IsIncremental(self)
4023
4024    def Size(self):
4025        return _pywrapcp.IntVarLocalSearchOperator_Size(self)
4026
4027    def Value(self, index):
4028        r"""
4029        Returns the value in the current assignment of the variable of given
4030        index.
4031        """
4032        return _pywrapcp.IntVarLocalSearchOperator_Value(self, index)
4033
4034    def Var(self, index):
4035        r""" Returns the variable of given index."""
4036        return _pywrapcp.IntVarLocalSearchOperator_Var(self, index)
4037
4038    def OldValue(self, index):
4039        return _pywrapcp.IntVarLocalSearchOperator_OldValue(self, index)
4040
4041    def PrevValue(self, index):
4042        return _pywrapcp.IntVarLocalSearchOperator_PrevValue(self, index)
4043
4044    def SetValue(self, index, value):
4045        return _pywrapcp.IntVarLocalSearchOperator_SetValue(self, index, value)
4046
4047    def Activated(self, index):
4048        return _pywrapcp.IntVarLocalSearchOperator_Activated(self, index)
4049
4050    def Activate(self, index):
4051        return _pywrapcp.IntVarLocalSearchOperator_Activate(self, index)
4052
4053    def Deactivate(self, index):
4054        return _pywrapcp.IntVarLocalSearchOperator_Deactivate(self, index)
4055
4056    def AddVars(self, vars):
4057        return _pywrapcp.IntVarLocalSearchOperator_AddVars(self, vars)
4058
4059    def OnStart(self):
4060        r"""
4061        Called by Start() after synchronizing the operator with the current
4062        assignment. Should be overridden instead of Start() to avoid calling
4063        IntVarLocalSearchOperator::Start explicitly.
4064        """
4065        return _pywrapcp.IntVarLocalSearchOperator_OnStart(self)
4066
4067    def NextNeighbor(self, delta, deltadelta):
4068        r"""
4069        OnStart() should really be protected, but then SWIG doesn't see it. So we
4070        make it public, but only subclasses should access to it (to override it).
4071        Redefines MakeNextNeighbor to export a simpler interface. The calls to
4072        ApplyChanges() and RevertChanges() are factored in this method, hiding
4073        both delta and deltadelta from subclasses which only need to override
4074        MakeOneNeighbor().
4075        Therefore this method should not be overridden. Override MakeOneNeighbor()
4076        instead.
4077        """
4078        return _pywrapcp.IntVarLocalSearchOperator_NextNeighbor(self, delta, deltadelta)
4079
4080    def OneNeighbor(self):
4081        r"""
4082        Creates a new neighbor. It returns false when the neighborhood is
4083        completely explored.
4084        MakeNextNeighbor() in a subclass of IntVarLocalSearchOperator.
4085        """
4086        return _pywrapcp.IntVarLocalSearchOperator_OneNeighbor(self)
4087    def __disown__(self):
4088        self.this.disown()
4089        _pywrapcp.disown_IntVarLocalSearchOperator(self)
4090        return weakref.proxy(self)
4091
4092# Register IntVarLocalSearchOperator in _pywrapcp:
4093_pywrapcp.IntVarLocalSearchOperator_swigregister(IntVarLocalSearchOperator)
4094class BaseLns(IntVarLocalSearchOperator):
4095    r"""
4096    This is the base class for building an Lns operator. An Lns fragment is a
4097    collection of variables which will be relaxed. Fragments are built with
4098    NextFragment(), which returns false if there are no more fragments to build.
4099    Optionally one can override InitFragments, which is called from
4100    LocalSearchOperator::Start to initialize fragment data.
4101
4102    Here's a sample relaxing one variable at a time:
4103
4104    class OneVarLns : public BaseLns {
4105     public:
4106      OneVarLns(const std::vector<IntVar*>& vars) : BaseLns(vars), index_(0) {}
4107      virtual ~OneVarLns() {}
4108      virtual void InitFragments() { index_ = 0; }
4109      virtual bool NextFragment() {
4110        const int size = Size();
4111        if (index_ < size) {
4112          AppendToFragment(index_);
4113          ++index_;
4114          return true;
4115        } else {
4116          return false;
4117        }
4118      }
4119
4120     private:
4121      int index_;
4122    };
4123    """
4124
4125    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4126    __repr__ = _swig_repr
4127
4128    def __init__(self, vars):
4129        if self.__class__ == BaseLns:
4130            _self = None
4131        else:
4132            _self = self
4133        _pywrapcp.BaseLns_swiginit(self, _pywrapcp.new_BaseLns(_self, vars))
4134    __swig_destroy__ = _pywrapcp.delete_BaseLns
4135
4136    def InitFragments(self):
4137        return _pywrapcp.BaseLns_InitFragments(self)
4138
4139    def NextFragment(self):
4140        return _pywrapcp.BaseLns_NextFragment(self)
4141
4142    def AppendToFragment(self, index):
4143        return _pywrapcp.BaseLns_AppendToFragment(self, index)
4144
4145    def FragmentSize(self):
4146        return _pywrapcp.BaseLns_FragmentSize(self)
4147
4148    def __getitem__(self, index):
4149        return _pywrapcp.BaseLns___getitem__(self, index)
4150
4151    def __len__(self):
4152        return _pywrapcp.BaseLns___len__(self)
4153    def __disown__(self):
4154        self.this.disown()
4155        _pywrapcp.disown_BaseLns(self)
4156        return weakref.proxy(self)
4157
4158# Register BaseLns in _pywrapcp:
4159_pywrapcp.BaseLns_swigregister(BaseLns)
4160class ChangeValue(IntVarLocalSearchOperator):
4161    r"""
4162    Defines operators which change the value of variables;
4163    each neighbor corresponds to *one* modified variable.
4164    Sub-classes have to define ModifyValue which determines what the new
4165    variable value is going to be (given the current value and the variable).
4166    """
4167
4168    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4169    __repr__ = _swig_repr
4170
4171    def __init__(self, vars):
4172        if self.__class__ == ChangeValue:
4173            _self = None
4174        else:
4175            _self = self
4176        _pywrapcp.ChangeValue_swiginit(self, _pywrapcp.new_ChangeValue(_self, vars))
4177    __swig_destroy__ = _pywrapcp.delete_ChangeValue
4178
4179    def ModifyValue(self, index, value):
4180        return _pywrapcp.ChangeValue_ModifyValue(self, index, value)
4181
4182    def OneNeighbor(self):
4183        r""" This method should not be overridden. Override ModifyValue() instead."""
4184        return _pywrapcp.ChangeValue_OneNeighbor(self)
4185    def __disown__(self):
4186        self.this.disown()
4187        _pywrapcp.disown_ChangeValue(self)
4188        return weakref.proxy(self)
4189
4190# Register ChangeValue in _pywrapcp:
4191_pywrapcp.ChangeValue_swigregister(ChangeValue)
4192class PathOperator(IntVarLocalSearchOperator):
4193    r"""
4194    Base class of the local search operators dedicated to path modifications
4195    (a path is a set of nodes linked together by arcs).
4196    This family of neighborhoods supposes they are handling next variables
4197    representing the arcs (var[i] represents the node immediately after i on
4198    a path).
4199    Several services are provided:
4200    - arc manipulators (SetNext(), ReverseChain(), MoveChain())
4201    - path inspectors (Next(), Prev(), IsPathEnd())
4202    - path iterators: operators need a given number of nodes to define a
4203      neighbor; this class provides the iteration on a given number of (base)
4204      nodes which can be used to define a neighbor (through the BaseNode method)
4205    Subclasses only need to override MakeNeighbor to create neighbors using
4206    the services above (no direct manipulation of assignments).
4207    """
4208
4209    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4210
4211    def __init__(self, *args, **kwargs):
4212        raise AttributeError("No constructor defined - class is abstract")
4213    __repr__ = _swig_repr
4214
4215    def Neighbor(self):
4216        return _pywrapcp.PathOperator_Neighbor(self)
4217
4218# Register PathOperator in _pywrapcp:
4219_pywrapcp.PathOperator_swigregister(PathOperator)
4220class LocalSearchFilter(BaseObject):
4221    r"""
4222    Classes to which this template function can be applied to as of 04/2014.
4223    Usage: LocalSearchOperator* op = MakeLocalSearchOperator<Relocate>(...);
4224    class TwoOpt;
4225    class Relocate;
4226    class Exchange;
4227    class Cross;
4228    class MakeActiveOperator;
4229    class MakeInactiveOperator;
4230    class MakeChainInactiveOperator;
4231    class SwapActiveOperator;
4232    class ExtendedSwapActiveOperator;
4233    class MakeActiveAndRelocate;
4234    class RelocateAndMakeActiveOperator;
4235    class RelocateAndMakeInactiveOperator;
4236    Local Search Filters are used for fast neighbor pruning.
4237    Filtering a move is done in several phases:
4238    - in the Relax phase, filters determine which parts of their internals
4239      will be changed by the candidate, and modify intermediary State
4240    - in the Accept phase, filters check that the candidate is feasible,
4241    - if the Accept phase succeeds, the solver may decide to trigger a
4242      Synchronize phase that makes filters change their internal representation
4243      to the last candidate,
4244    - otherwise (Accept fails or the solver does not want to synchronize),
4245      a Revert phase makes filters erase any intermediary State generated by the
4246      Relax and Accept phases.
4247    A given filter has phases called with the following pattern:
4248    (Relax.Accept.Synchronize | Relax.Accept.Revert | Relax.Revert)*.
4249    Filters's Revert() is always called in the reverse order their Accept() was
4250    called, to allow late filters to use state done/undone by early filters'
4251    Accept()/Revert().
4252    """
4253
4254    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4255
4256    def __init__(self, *args, **kwargs):
4257        raise AttributeError("No constructor defined - class is abstract")
4258    __repr__ = _swig_repr
4259
4260    def Accept(self, delta, deltadelta, objective_min, objective_max):
4261        r"""
4262        Accepts a "delta" given the assignment with which the filter has been
4263        synchronized; the delta holds the variables which have been modified and
4264        their new value.
4265        If the filter represents a part of the global objective, its contribution
4266        must be between objective_min and objective_max.
4267        Sample: supposing one wants to maintain a[0,1] + b[0,1] <= 1,
4268        for the assignment (a,1), (b,0), the delta (b,1) will be rejected
4269        but the delta (a,0) will be accepted.
4270        TODO(user): Remove arguments when there are no more need for those.
4271        """
4272        return _pywrapcp.LocalSearchFilter_Accept(self, delta, deltadelta, objective_min, objective_max)
4273
4274    def IsIncremental(self):
4275        return _pywrapcp.LocalSearchFilter_IsIncremental(self)
4276
4277    def Synchronize(self, assignment, delta):
4278        r"""
4279        Synchronizes the filter with the current solution, delta being the
4280        difference with the solution passed to the previous call to Synchronize()
4281        or IncrementalSynchronize(). 'delta' can be used to incrementally
4282        synchronizing the filter with the new solution by only considering the
4283        changes in delta.
4284        """
4285        return _pywrapcp.LocalSearchFilter_Synchronize(self, assignment, delta)
4286    __swig_destroy__ = _pywrapcp.delete_LocalSearchFilter
4287
4288# Register LocalSearchFilter in _pywrapcp:
4289_pywrapcp.LocalSearchFilter_swigregister(LocalSearchFilter)
4290class LocalSearchFilterManager(BaseObject):
4291    r"""
4292    Filter manager: when a move is made, filters are executed to decide whether
4293    the solution is feasible and compute parts of the new cost. This class
4294    schedules filter execution and composes costs as a sum.
4295    """
4296
4297    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4298    __repr__ = _swig_repr
4299
4300    def DebugString(self):
4301        return _pywrapcp.LocalSearchFilterManager_DebugString(self)
4302
4303    def __init__(self, *args):
4304        _pywrapcp.LocalSearchFilterManager_swiginit(self, _pywrapcp.new_LocalSearchFilterManager(*args))
4305
4306    def Accept(self, monitor, delta, deltadelta, objective_min, objective_max):
4307        r"""
4308        Returns true iff all filters return true, and the sum of their accepted
4309        objectives is between objective_min and objective_max.
4310        The monitor has its Begin/EndFiltering events triggered.
4311        """
4312        return _pywrapcp.LocalSearchFilterManager_Accept(self, monitor, delta, deltadelta, objective_min, objective_max)
4313
4314    def Synchronize(self, assignment, delta):
4315        r""" Synchronizes all filters to assignment."""
4316        return _pywrapcp.LocalSearchFilterManager_Synchronize(self, assignment, delta)
4317    __swig_destroy__ = _pywrapcp.delete_LocalSearchFilterManager
4318
4319# Register LocalSearchFilterManager in _pywrapcp:
4320_pywrapcp.LocalSearchFilterManager_swigregister(LocalSearchFilterManager)
4321class IntVarLocalSearchFilter(LocalSearchFilter):
4322    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4323    __repr__ = _swig_repr
4324
4325    def __init__(self, vars):
4326        if self.__class__ == IntVarLocalSearchFilter:
4327            _self = None
4328        else:
4329            _self = self
4330        _pywrapcp.IntVarLocalSearchFilter_swiginit(self, _pywrapcp.new_IntVarLocalSearchFilter(_self, vars))
4331    __swig_destroy__ = _pywrapcp.delete_IntVarLocalSearchFilter
4332
4333    def Synchronize(self, assignment, delta):
4334        r"""
4335        This method should not be overridden. Override OnSynchronize() instead
4336        which is called before exiting this method.
4337        """
4338        return _pywrapcp.IntVarLocalSearchFilter_Synchronize(self, assignment, delta)
4339
4340    def Size(self):
4341        return _pywrapcp.IntVarLocalSearchFilter_Size(self)
4342
4343    def Value(self, index):
4344        return _pywrapcp.IntVarLocalSearchFilter_Value(self, index)
4345
4346    def IndexFromVar(self, var):
4347        return _pywrapcp.IntVarLocalSearchFilter_IndexFromVar(self, var)
4348    def __disown__(self):
4349        self.this.disown()
4350        _pywrapcp.disown_IntVarLocalSearchFilter(self)
4351        return weakref.proxy(self)
4352
4353# Register IntVarLocalSearchFilter in _pywrapcp:
4354_pywrapcp.IntVarLocalSearchFilter_swigregister(IntVarLocalSearchFilter)
4355class BooleanVar(IntVar):
4356    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4357
4358    def __init__(self, *args, **kwargs):
4359        raise AttributeError("No constructor defined - class is abstract")
4360    __repr__ = _swig_repr
4361
4362    def Min(self):
4363        return _pywrapcp.BooleanVar_Min(self)
4364
4365    def SetMin(self, m):
4366        return _pywrapcp.BooleanVar_SetMin(self, m)
4367
4368    def Max(self):
4369        return _pywrapcp.BooleanVar_Max(self)
4370
4371    def SetMax(self, m):
4372        return _pywrapcp.BooleanVar_SetMax(self, m)
4373
4374    def SetRange(self, mi, ma):
4375        return _pywrapcp.BooleanVar_SetRange(self, mi, ma)
4376
4377    def Bound(self):
4378        return _pywrapcp.BooleanVar_Bound(self)
4379
4380    def Value(self):
4381        return _pywrapcp.BooleanVar_Value(self)
4382
4383    def RemoveValue(self, v):
4384        return _pywrapcp.BooleanVar_RemoveValue(self, v)
4385
4386    def RemoveInterval(self, l, u):
4387        return _pywrapcp.BooleanVar_RemoveInterval(self, l, u)
4388
4389    def WhenBound(self, d):
4390        return _pywrapcp.BooleanVar_WhenBound(self, d)
4391
4392    def WhenRange(self, d):
4393        return _pywrapcp.BooleanVar_WhenRange(self, d)
4394
4395    def WhenDomain(self, d):
4396        return _pywrapcp.BooleanVar_WhenDomain(self, d)
4397
4398    def Size(self):
4399        return _pywrapcp.BooleanVar_Size(self)
4400
4401    def Contains(self, v):
4402        return _pywrapcp.BooleanVar_Contains(self, v)
4403
4404    def HoleIteratorAux(self, reversible):
4405        return _pywrapcp.BooleanVar_HoleIteratorAux(self, reversible)
4406
4407    def DomainIteratorAux(self, reversible):
4408        return _pywrapcp.BooleanVar_DomainIteratorAux(self, reversible)
4409
4410    def DebugString(self):
4411        return _pywrapcp.BooleanVar_DebugString(self)
4412
4413# Register BooleanVar in _pywrapcp:
4414_pywrapcp.BooleanVar_swigregister(BooleanVar)
4415
4416class PyDecision(Decision):
4417
4418  def __init__(self):
4419    Decision.__init__(self)
4420
4421  def ApplyWrapper(self, solver):
4422    try:
4423       self.Apply(solver)
4424    except Exception as e:
4425      if 'CP Solver fail' in str(e):
4426        solver.ShouldFail()
4427      else:
4428        raise
4429
4430  def RefuteWrapper(self, solver):
4431    try:
4432       self.Refute(solver)
4433    except Exception as e:
4434      if 'CP Solver fail' in str(e):
4435        solver.ShouldFail()
4436      else:
4437        raise
4438
4439  def DebugString(self):
4440    return "PyDecision"
4441
4442
4443class PyDecisionBuilder(DecisionBuilder):
4444
4445  def __init__(self):
4446    DecisionBuilder.__init__(self)
4447
4448  def NextWrapper(self, solver):
4449    try:
4450      return self.Next(solver)
4451    except Exception as e:
4452      if 'CP Solver fail' in str(e):
4453        return solver.FailDecision()
4454      else:
4455        raise
4456
4457  def DebugString(self):
4458    return "PyDecisionBuilder"
4459
4460
4461class PyDemon(Demon):
4462
4463  def RunWrapper(self, solver):
4464    try:
4465      self.Run(solver)
4466    except Exception as e:
4467      if 'CP Solver fail' in str(e):
4468        solver.ShouldFail()
4469      else:
4470        raise
4471
4472  def DebugString(self):
4473    return "PyDemon"
4474
4475
4476class PyConstraintDemon(PyDemon):
4477
4478  def __init__(self, ct, method, delayed, *args):
4479    PyDemon.__init__(self)
4480    self.__constraint = ct
4481    self.__method = method
4482    self.__delayed = delayed
4483    self.__args = args
4484
4485  def Run(self, solver):
4486    self.__method(self.__constraint, *self.__args)
4487
4488  def Priority(self):
4489    return Solver.DELAYED_PRIORITY if self.__delayed else Solver.NORMAL_PRIORITY
4490
4491  def DebugString(self):
4492    return 'PyConstraintDemon'
4493
4494
4495class PyConstraint(Constraint):
4496
4497  def __init__(self, solver):
4498    Constraint.__init__(self, solver)
4499    self.__demons = []
4500
4501  def Demon(self, method, *args):
4502    demon = PyConstraintDemon(self, method, False, *args)
4503    self.__demons.append(demon)
4504    return demon
4505
4506  def DelayedDemon(self, method, *args):
4507    demon = PyConstraintDemon(self, method, True, *args)
4508    self.__demons.append(demon)
4509    return demon
4510
4511  def InitialPropagateDemon(self):
4512    return self.solver().ConstraintInitialPropagateCallback(self)
4513
4514  def DelayedInitialPropagateDemon(self):
4515    return self.solver().DelayedConstraintInitialPropagateCallback(self)
4516
4517  def InitialPropagateWrapper(self):
4518    try:
4519      self.InitialPropagate()
4520    except Exception as e:
4521      if 'CP Solver fail' in str(e):
4522        self.solver().ShouldFail()
4523      else:
4524        raise
4525
4526  def DebugString(self):
4527    return "PyConstraint"
4528
4529
4530
4531class RoutingIndexManager(object):
4532    r"""
4533    Manager for any NodeIndex <-> variable index conversion. The routing solver
4534    uses variable indices internally and through its API. These variable indices
4535    are tricky to manage directly because one Node can correspond to a multitude
4536    of variables, depending on the number of times they appear in the model, and
4537    if they're used as start and/or end points. This class aims to simplify
4538    variable index usage, allowing users to use NodeIndex instead.
4539
4540    Usage:
4541
4542      .. code-block:: c++
4543
4544          auto starts_ends = ...;  /// These are NodeIndex.
4545          RoutingIndexManager manager(10, 4, starts_ends);  // 10 nodes, 4 vehicles.
4546          RoutingModel model(manager);
4547
4548    Then, use 'manager.NodeToIndex(node)' whenever model requires a variable
4549    index.
4550
4551    Note: the mapping between node indices and variables indices is subject to
4552    change so no assumption should be made on it. The only guarantee is that
4553    indices range between 0 and n-1, where n = number of vehicles * 2 (for start
4554    and end nodes) + number of non-start or end nodes.
4555    """
4556
4557    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4558    __repr__ = _swig_repr
4559
4560    def __init__(self, *args):
4561        _pywrapcp.RoutingIndexManager_swiginit(self, _pywrapcp.new_RoutingIndexManager(*args))
4562
4563    def GetNumberOfNodes(self):
4564        return _pywrapcp.RoutingIndexManager_GetNumberOfNodes(self)
4565
4566    def GetNumberOfVehicles(self):
4567        return _pywrapcp.RoutingIndexManager_GetNumberOfVehicles(self)
4568
4569    def GetNumberOfIndices(self):
4570        return _pywrapcp.RoutingIndexManager_GetNumberOfIndices(self)
4571
4572    def GetStartIndex(self, vehicle):
4573        return _pywrapcp.RoutingIndexManager_GetStartIndex(self, vehicle)
4574
4575    def GetEndIndex(self, vehicle):
4576        return _pywrapcp.RoutingIndexManager_GetEndIndex(self, vehicle)
4577
4578    def NodeToIndex(self, node):
4579        return _pywrapcp.RoutingIndexManager_NodeToIndex(self, node)
4580
4581    def IndexToNode(self, index):
4582        return _pywrapcp.RoutingIndexManager_IndexToNode(self, index)
4583    __swig_destroy__ = _pywrapcp.delete_RoutingIndexManager
4584
4585# Register RoutingIndexManager in _pywrapcp:
4586_pywrapcp.RoutingIndexManager_swigregister(RoutingIndexManager)
4587
4588def DefaultRoutingModelParameters():
4589    return _pywrapcp.DefaultRoutingModelParameters()
4590
4591def DefaultRoutingSearchParameters():
4592    return _pywrapcp.DefaultRoutingSearchParameters()
4593
4594def FindErrorInRoutingSearchParameters(search_parameters):
4595    r"""
4596    Returns an empty std::string if the routing search parameters are valid, and
4597    a non-empty, human readable error description if they're not.
4598    """
4599    return _pywrapcp.FindErrorInRoutingSearchParameters(search_parameters)
4600BOOL_UNSPECIFIED = _pywrapcp.BOOL_UNSPECIFIED
4601BOOL_FALSE = _pywrapcp.BOOL_FALSE
4602BOOL_TRUE = _pywrapcp.BOOL_TRUE
4603class FirstSolutionStrategy(object):
4604    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4605    __repr__ = _swig_repr
4606
4607    def __init__(self):
4608        _pywrapcp.FirstSolutionStrategy_swiginit(self, _pywrapcp.new_FirstSolutionStrategy())
4609    __swig_destroy__ = _pywrapcp.delete_FirstSolutionStrategy
4610
4611# Register FirstSolutionStrategy in _pywrapcp:
4612_pywrapcp.FirstSolutionStrategy_swigregister(FirstSolutionStrategy)
4613class LocalSearchMetaheuristic(object):
4614    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4615    __repr__ = _swig_repr
4616
4617    def __init__(self):
4618        _pywrapcp.LocalSearchMetaheuristic_swiginit(self, _pywrapcp.new_LocalSearchMetaheuristic())
4619    __swig_destroy__ = _pywrapcp.delete_LocalSearchMetaheuristic
4620
4621# Register LocalSearchMetaheuristic in _pywrapcp:
4622_pywrapcp.LocalSearchMetaheuristic_swigregister(LocalSearchMetaheuristic)
4623class PathsMetadata(object):
4624    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4625    __repr__ = _swig_repr
4626
4627    def __init__(self, manager):
4628        _pywrapcp.PathsMetadata_swiginit(self, _pywrapcp.new_PathsMetadata(manager))
4629
4630    def IsStart(self, node):
4631        return _pywrapcp.PathsMetadata_IsStart(self, node)
4632
4633    def IsEnd(self, node):
4634        return _pywrapcp.PathsMetadata_IsEnd(self, node)
4635
4636    def GetPath(self, start_or_end_node):
4637        return _pywrapcp.PathsMetadata_GetPath(self, start_or_end_node)
4638
4639    def NumPaths(self):
4640        return _pywrapcp.PathsMetadata_NumPaths(self)
4641
4642    def Paths(self):
4643        return _pywrapcp.PathsMetadata_Paths(self)
4644
4645    def Starts(self):
4646        return _pywrapcp.PathsMetadata_Starts(self)
4647
4648    def Ends(self):
4649        return _pywrapcp.PathsMetadata_Ends(self)
4650    __swig_destroy__ = _pywrapcp.delete_PathsMetadata
4651
4652# Register PathsMetadata in _pywrapcp:
4653_pywrapcp.PathsMetadata_swigregister(PathsMetadata)
4654class RoutingModel(object):
4655    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4656    __repr__ = _swig_repr
4657    ROUTING_NOT_SOLVED = _pywrapcp.RoutingModel_ROUTING_NOT_SOLVED
4658    r""" Problem not solved yet (before calling RoutingModel::Solve())."""
4659    ROUTING_SUCCESS = _pywrapcp.RoutingModel_ROUTING_SUCCESS
4660    r""" Problem solved successfully after calling RoutingModel::Solve()."""
4661    ROUTING_PARTIAL_SUCCESS_LOCAL_OPTIMUM_NOT_REACHED = _pywrapcp.RoutingModel_ROUTING_PARTIAL_SUCCESS_LOCAL_OPTIMUM_NOT_REACHED
4662    r"""
4663    Problem solved successfully after calling RoutingModel::Solve(), except
4664    that a local optimum has not been reached. Leaving more time would allow
4665    improving the solution.
4666    """
4667    ROUTING_FAIL = _pywrapcp.RoutingModel_ROUTING_FAIL
4668    r""" No solution found to the problem after calling RoutingModel::Solve()."""
4669    ROUTING_FAIL_TIMEOUT = _pywrapcp.RoutingModel_ROUTING_FAIL_TIMEOUT
4670    r""" Time limit reached before finding a solution with RoutingModel::Solve()."""
4671    ROUTING_INVALID = _pywrapcp.RoutingModel_ROUTING_INVALID
4672    r""" Model, model parameters or flags are not valid."""
4673    ROUTING_INFEASIBLE = _pywrapcp.RoutingModel_ROUTING_INFEASIBLE
4674    r""" Problem proven to be infeasible."""
4675    PICKUP_AND_DELIVERY_NO_ORDER = _pywrapcp.RoutingModel_PICKUP_AND_DELIVERY_NO_ORDER
4676    r""" Any precedence is accepted."""
4677    PICKUP_AND_DELIVERY_LIFO = _pywrapcp.RoutingModel_PICKUP_AND_DELIVERY_LIFO
4678    r""" Deliveries must be performed in reverse order of pickups."""
4679    PICKUP_AND_DELIVERY_FIFO = _pywrapcp.RoutingModel_PICKUP_AND_DELIVERY_FIFO
4680    r""" Deliveries must be performed in the same order as pickups."""
4681
4682    def __init__(self, *args):
4683        _pywrapcp.RoutingModel_swiginit(self, _pywrapcp.new_RoutingModel(*args))
4684    __swig_destroy__ = _pywrapcp.delete_RoutingModel
4685    kTransitEvaluatorSignUnknown = _pywrapcp.RoutingModel_kTransitEvaluatorSignUnknown
4686    kTransitEvaluatorSignPositiveOrZero = _pywrapcp.RoutingModel_kTransitEvaluatorSignPositiveOrZero
4687    kTransitEvaluatorSignNegativeOrZero = _pywrapcp.RoutingModel_kTransitEvaluatorSignNegativeOrZero
4688
4689    def RegisterUnaryTransitVector(self, values):
4690        r"""
4691        Registers 'callback' and returns its index.
4692        The sign parameter allows to notify the solver that the callback only
4693        return values of the given sign. This can help the solver, but passing
4694        an incorrect sign may crash in non-opt compilation mode, and yield
4695        incorrect results in opt.
4696        """
4697        return _pywrapcp.RoutingModel_RegisterUnaryTransitVector(self, values)
4698
4699    def RegisterUnaryTransitCallback(self, *args):
4700        return _pywrapcp.RoutingModel_RegisterUnaryTransitCallback(self, *args)
4701
4702    def RegisterTransitMatrix(self, values):
4703        return _pywrapcp.RoutingModel_RegisterTransitMatrix(self, values)
4704
4705    def RegisterTransitCallback(self, *args):
4706        return _pywrapcp.RoutingModel_RegisterTransitCallback(self, *args)
4707
4708    def TransitCallback(self, callback_index):
4709        return _pywrapcp.RoutingModel_TransitCallback(self, callback_index)
4710
4711    def UnaryTransitCallbackOrNull(self, callback_index):
4712        return _pywrapcp.RoutingModel_UnaryTransitCallbackOrNull(self, callback_index)
4713
4714    def AddDimension(self, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name):
4715        r"""
4716        Model creation
4717        Methods to add dimensions to routes; dimensions represent quantities
4718        accumulated at nodes along the routes. They represent quantities such as
4719        weights or volumes carried along the route, or distance or times.
4720        Quantities at a node are represented by "cumul" variables and the increase
4721        or decrease of quantities between nodes are represented by "transit"
4722        variables. These variables are linked as follows:
4723        if j == next(i), cumul(j) = cumul(i) + transit(i, j) + slack(i)
4724        where slack is a positive slack variable (can represent waiting times for
4725        a time dimension).
4726        Setting the value of fix_start_cumul_to_zero to true will force the
4727        "cumul" variable of the start node of all vehicles to be equal to 0.
4728        Creates a dimension where the transit variable is constrained to be
4729        equal to evaluator(i, next(i)); 'slack_max' is the upper bound of the
4730        slack variable and 'capacity' is the upper bound of the cumul variables.
4731        'name' is the name used to reference the dimension; this name is used to
4732        get cumul and transit variables from the routing model.
4733        Returns false if a dimension with the same name has already been created
4734        (and doesn't create the new dimension).
4735        Takes ownership of the callback 'evaluator'.
4736        """
4737        return _pywrapcp.RoutingModel_AddDimension(self, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name)
4738
4739    def AddDimensionWithVehicleTransits(self, evaluator_indices, slack_max, capacity, fix_start_cumul_to_zero, name):
4740        return _pywrapcp.RoutingModel_AddDimensionWithVehicleTransits(self, evaluator_indices, slack_max, capacity, fix_start_cumul_to_zero, name)
4741
4742    def AddDimensionWithVehicleCapacity(self, evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name):
4743        return _pywrapcp.RoutingModel_AddDimensionWithVehicleCapacity(self, evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name)
4744
4745    def AddDimensionWithVehicleTransitAndCapacity(self, evaluator_indices, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name):
4746        return _pywrapcp.RoutingModel_AddDimensionWithVehicleTransitAndCapacity(self, evaluator_indices, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name)
4747
4748    def AddConstantDimensionWithSlack(self, value, capacity, slack_max, fix_start_cumul_to_zero, name):
4749        r"""
4750        Creates a dimension where the transit variable is constrained to be
4751        equal to 'value'; 'capacity' is the upper bound of the cumul variables.
4752        'name' is the name used to reference the dimension; this name is used to
4753        get cumul and transit variables from the routing model.
4754        Returns a pair consisting of an index to the registered unary transit
4755        callback and a bool denoting whether the dimension has been created.
4756        It is false if a dimension with the same name has already been created
4757        (and doesn't create the new dimension but still register a new callback).
4758        """
4759        return _pywrapcp.RoutingModel_AddConstantDimensionWithSlack(self, value, capacity, slack_max, fix_start_cumul_to_zero, name)
4760
4761    def AddConstantDimension(self, value, capacity, fix_start_cumul_to_zero, name):
4762        return _pywrapcp.RoutingModel_AddConstantDimension(self, value, capacity, fix_start_cumul_to_zero, name)
4763
4764    def AddVectorDimension(self, values, capacity, fix_start_cumul_to_zero, name):
4765        r"""
4766        Creates a dimension where the transit variable is constrained to be
4767        equal to 'values[i]' for node i; 'capacity' is the upper bound of
4768        the cumul variables. 'name' is the name used to reference the dimension;
4769        this name is used to get cumul and transit variables from the routing
4770        model.
4771        Returns a pair consisting of an index to the registered unary transit
4772        callback and a bool denoting whether the dimension has been created.
4773        It is false if a dimension with the same name has already been created
4774        (and doesn't create the new dimension but still register a new callback).
4775        """
4776        return _pywrapcp.RoutingModel_AddVectorDimension(self, values, capacity, fix_start_cumul_to_zero, name)
4777
4778    def AddMatrixDimension(self, values, capacity, fix_start_cumul_to_zero, name):
4779        r"""
4780        Creates a dimension where the transit variable is constrained to be
4781        equal to 'values[i][next(i)]' for node i; 'capacity' is the upper bound of
4782        the cumul variables. 'name' is the name used to reference the dimension;
4783        this name is used to get cumul and transit variables from the routing
4784        model.
4785        Returns a pair consisting of an index to the registered transit callback
4786        and a bool denoting whether the dimension has been created.
4787        It is false if a dimension with the same name has already been created
4788        (and doesn't create the new dimension but still register a new callback).
4789        """
4790        return _pywrapcp.RoutingModel_AddMatrixDimension(self, values, capacity, fix_start_cumul_to_zero, name)
4791
4792    def GetAllDimensionNames(self):
4793        r""" Outputs the names of all dimensions added to the routing engine."""
4794        return _pywrapcp.RoutingModel_GetAllDimensionNames(self)
4795
4796    def GetDimensions(self):
4797        r""" Returns all dimensions of the model."""
4798        return _pywrapcp.RoutingModel_GetDimensions(self)
4799
4800    def GetDimensionsWithSoftOrSpanCosts(self):
4801        r""" Returns dimensions with soft or vehicle span costs."""
4802        return _pywrapcp.RoutingModel_GetDimensionsWithSoftOrSpanCosts(self)
4803
4804    def GetDimensionsWithGlobalCumulOptimizers(self):
4805        r""" Returns the dimensions which have [global|local]_dimension_optimizers_."""
4806        return _pywrapcp.RoutingModel_GetDimensionsWithGlobalCumulOptimizers(self)
4807
4808    def GetDimensionsWithLocalCumulOptimizers(self):
4809        return _pywrapcp.RoutingModel_GetDimensionsWithLocalCumulOptimizers(self)
4810
4811    def HasGlobalCumulOptimizer(self, dimension):
4812        r""" Returns whether the given dimension has global/local cumul optimizers."""
4813        return _pywrapcp.RoutingModel_HasGlobalCumulOptimizer(self, dimension)
4814
4815    def HasLocalCumulOptimizer(self, dimension):
4816        return _pywrapcp.RoutingModel_HasLocalCumulOptimizer(self, dimension)
4817
4818    def GetMutableGlobalCumulLPOptimizer(self, dimension):
4819        r"""
4820        Returns the global/local dimension cumul optimizer for a given dimension,
4821        or nullptr if there is none.
4822        """
4823        return _pywrapcp.RoutingModel_GetMutableGlobalCumulLPOptimizer(self, dimension)
4824
4825    def GetMutableGlobalCumulMPOptimizer(self, dimension):
4826        return _pywrapcp.RoutingModel_GetMutableGlobalCumulMPOptimizer(self, dimension)
4827
4828    def GetMutableLocalCumulLPOptimizer(self, dimension):
4829        return _pywrapcp.RoutingModel_GetMutableLocalCumulLPOptimizer(self, dimension)
4830
4831    def GetMutableLocalCumulMPOptimizer(self, dimension):
4832        return _pywrapcp.RoutingModel_GetMutableLocalCumulMPOptimizer(self, dimension)
4833
4834    def HasDimension(self, dimension_name):
4835        r""" Returns true if a dimension exists for a given dimension name."""
4836        return _pywrapcp.RoutingModel_HasDimension(self, dimension_name)
4837
4838    def GetDimensionOrDie(self, dimension_name):
4839        r""" Returns a dimension from its name. Dies if the dimension does not exist."""
4840        return _pywrapcp.RoutingModel_GetDimensionOrDie(self, dimension_name)
4841
4842    def GetMutableDimension(self, dimension_name):
4843        r"""
4844        Returns a dimension from its name. Returns nullptr if the dimension does
4845        not exist.
4846        """
4847        return _pywrapcp.RoutingModel_GetMutableDimension(self, dimension_name)
4848
4849    def SetPrimaryConstrainedDimension(self, dimension_name):
4850        r"""
4851        Set the given dimension as "primary constrained". As of August 2013, this
4852        is only used by ArcIsMoreConstrainedThanArc().
4853        "dimension" must be the name of an existing dimension, or be empty, in
4854        which case there will not be a primary dimension after this call.
4855        """
4856        return _pywrapcp.RoutingModel_SetPrimaryConstrainedDimension(self, dimension_name)
4857
4858    def GetPrimaryConstrainedDimension(self):
4859        r""" Get the primary constrained dimension, or an empty string if it is unset."""
4860        return _pywrapcp.RoutingModel_GetPrimaryConstrainedDimension(self)
4861
4862    def AddResourceGroup(self):
4863        r"""
4864        Adds a resource group to the routing model. Returns its index in
4865        resource_groups_.
4866        """
4867        return _pywrapcp.RoutingModel_AddResourceGroup(self)
4868
4869    def GetResourceGroups(self):
4870        return _pywrapcp.RoutingModel_GetResourceGroups(self)
4871
4872    def GetResourceGroup(self, rg_index):
4873        return _pywrapcp.RoutingModel_GetResourceGroup(self, rg_index)
4874
4875    def GetDimensionResourceGroupIndices(self, dimension):
4876        r"""
4877        Returns the indices of resource groups for this dimension. This method can
4878        only be called after the model has been closed.
4879        """
4880        return _pywrapcp.RoutingModel_GetDimensionResourceGroupIndices(self, dimension)
4881
4882    def GetDimensionResourceGroupIndex(self, dimension):
4883        r"""
4884        Returns the index of the resource group attached to the dimension.
4885        DCHECKS that there's exactly one resource group for this dimension.
4886        """
4887        return _pywrapcp.RoutingModel_GetDimensionResourceGroupIndex(self, dimension)
4888
4889    def AddDisjunction(self, *args):
4890        r"""
4891        Adds a disjunction constraint on the indices: exactly 'max_cardinality' of
4892        the indices are active. Start and end indices of any vehicle cannot be
4893        part of a disjunction.
4894
4895        If a penalty is given, at most 'max_cardinality' of the indices can be
4896        active, and if less are active, 'penalty' is payed per inactive index.
4897        This is equivalent to adding the constraint:
4898            p + Sum(i)active[i] == max_cardinality
4899        where p is an integer variable, and the following cost to the cost
4900        function:
4901            p * penalty.
4902        'penalty' must be positive to make the disjunction optional; a negative
4903        penalty will force 'max_cardinality' indices of the disjunction to be
4904        performed, and therefore p == 0.
4905        Note: passing a vector with a single index will model an optional index
4906        with a penalty cost if it is not visited.
4907        """
4908        return _pywrapcp.RoutingModel_AddDisjunction(self, *args)
4909
4910    def GetDisjunctionIndices(self, index):
4911        r""" Returns the indices of the disjunctions to which an index belongs."""
4912        return _pywrapcp.RoutingModel_GetDisjunctionIndices(self, index)
4913
4914    def GetDisjunctionPenalty(self, index):
4915        r""" Returns the penalty of the node disjunction of index 'index'."""
4916        return _pywrapcp.RoutingModel_GetDisjunctionPenalty(self, index)
4917
4918    def GetDisjunctionMaxCardinality(self, index):
4919        r"""
4920        Returns the maximum number of possible active nodes of the node
4921        disjunction of index 'index'.
4922        """
4923        return _pywrapcp.RoutingModel_GetDisjunctionMaxCardinality(self, index)
4924
4925    def GetNumberOfDisjunctions(self):
4926        r""" Returns the number of node disjunctions in the model."""
4927        return _pywrapcp.RoutingModel_GetNumberOfDisjunctions(self)
4928
4929    def HasMandatoryDisjunctions(self):
4930        r"""
4931        Returns true if the model contains mandatory disjunctions (ones with
4932        kNoPenalty as penalty).
4933        """
4934        return _pywrapcp.RoutingModel_HasMandatoryDisjunctions(self)
4935
4936    def HasMaxCardinalityConstrainedDisjunctions(self):
4937        r"""
4938        Returns true if the model contains at least one disjunction which is
4939        constrained by its max_cardinality.
4940        """
4941        return _pywrapcp.RoutingModel_HasMaxCardinalityConstrainedDisjunctions(self)
4942
4943    def GetPerfectBinaryDisjunctions(self):
4944        r"""
4945        Returns the list of all perfect binary disjunctions, as pairs of variable
4946        indices: a disjunction is "perfect" when its variables do not appear in
4947        any other disjunction. Each pair is sorted (lowest variable index first),
4948        and the output vector is also sorted (lowest pairs first).
4949        """
4950        return _pywrapcp.RoutingModel_GetPerfectBinaryDisjunctions(self)
4951
4952    def IgnoreDisjunctionsAlreadyForcedToZero(self):
4953        r"""
4954        SPECIAL: Makes the solver ignore all the disjunctions whose active
4955        variables are all trivially zero (i.e. Max() == 0), by setting their
4956        max_cardinality to 0.
4957        This can be useful when using the BaseBinaryDisjunctionNeighborhood
4958        operators, in the context of arc-based routing.
4959        """
4960        return _pywrapcp.RoutingModel_IgnoreDisjunctionsAlreadyForcedToZero(self)
4961
4962    def AddSoftSameVehicleConstraint(self, indices, cost):
4963        r"""
4964        Adds a soft constraint to force a set of variable indices to be on the
4965        same vehicle. If all nodes are not on the same vehicle, each extra vehicle
4966        used adds 'cost' to the cost function.
4967        """
4968        return _pywrapcp.RoutingModel_AddSoftSameVehicleConstraint(self, indices, cost)
4969
4970    def SetAllowedVehiclesForIndex(self, vehicles, index):
4971        r"""
4972        Sets the vehicles which can visit a given node. If the node is in a
4973        disjunction, this will not prevent it from being unperformed.
4974        Specifying an empty vector of vehicles has no effect (all vehicles
4975        will be allowed to visit the node).
4976        """
4977        return _pywrapcp.RoutingModel_SetAllowedVehiclesForIndex(self, vehicles, index)
4978
4979    def IsVehicleAllowedForIndex(self, vehicle, index):
4980        r""" Returns true if a vehicle is allowed to visit a given node."""
4981        return _pywrapcp.RoutingModel_IsVehicleAllowedForIndex(self, vehicle, index)
4982
4983    def AddPickupAndDelivery(self, pickup, delivery):
4984        r"""
4985        Notifies that index1 and index2 form a pair of nodes which should belong
4986        to the same route. This methods helps the search find better solutions,
4987        especially in the local search phase.
4988        It should be called each time you have an equality constraint linking
4989        the vehicle variables of two node (including for instance pickup and
4990        delivery problems):
4991            Solver* const solver = routing.solver();
4992            int64_t index1 = manager.NodeToIndex(node1);
4993            int64_t index2 = manager.NodeToIndex(node2);
4994            solver->AddConstraint(solver->MakeEquality(
4995                routing.VehicleVar(index1),
4996                routing.VehicleVar(index2)));
4997            routing.AddPickupAndDelivery(index1, index2);
4998        """
4999        return _pywrapcp.RoutingModel_AddPickupAndDelivery(self, pickup, delivery)
5000
5001    def AddPickupAndDeliverySets(self, pickup_disjunction, delivery_disjunction):
5002        r"""
5003        Same as AddPickupAndDelivery but notifying that the performed node from
5004        the disjunction of index 'pickup_disjunction' is on the same route as the
5005        performed node from the disjunction of index 'delivery_disjunction'.
5006        """
5007        return _pywrapcp.RoutingModel_AddPickupAndDeliverySets(self, pickup_disjunction, delivery_disjunction)
5008
5009    def GetPickupIndexPairs(self, node_index):
5010        r"""
5011        Returns pairs for which the node is a pickup; the first element of each
5012        pair is the index in the pickup and delivery pairs list in which the
5013        pickup appears, the second element is its index in the pickups list.
5014        """
5015        return _pywrapcp.RoutingModel_GetPickupIndexPairs(self, node_index)
5016
5017    def GetDeliveryIndexPairs(self, node_index):
5018        r""" Same as above for deliveries."""
5019        return _pywrapcp.RoutingModel_GetDeliveryIndexPairs(self, node_index)
5020
5021    def SetPickupAndDeliveryPolicyOfAllVehicles(self, policy):
5022        r"""
5023        Sets the Pickup and delivery policy of all vehicles. It is equivalent to
5024        calling SetPickupAndDeliveryPolicyOfVehicle on all vehicles.
5025        """
5026        return _pywrapcp.RoutingModel_SetPickupAndDeliveryPolicyOfAllVehicles(self, policy)
5027
5028    def SetPickupAndDeliveryPolicyOfVehicle(self, policy, vehicle):
5029        return _pywrapcp.RoutingModel_SetPickupAndDeliveryPolicyOfVehicle(self, policy, vehicle)
5030
5031    def GetPickupAndDeliveryPolicyOfVehicle(self, vehicle):
5032        return _pywrapcp.RoutingModel_GetPickupAndDeliveryPolicyOfVehicle(self, vehicle)
5033
5034    def GetNumOfSingletonNodes(self):
5035        r"""
5036        Returns the number of non-start/end nodes which do not appear in a
5037        pickup/delivery pair.
5038        """
5039        return _pywrapcp.RoutingModel_GetNumOfSingletonNodes(self)
5040    TYPE_ADDED_TO_VEHICLE = _pywrapcp.RoutingModel_TYPE_ADDED_TO_VEHICLE
5041    r""" When visited, the number of types 'T' on the vehicle increases by one."""
5042    ADDED_TYPE_REMOVED_FROM_VEHICLE = _pywrapcp.RoutingModel_ADDED_TYPE_REMOVED_FROM_VEHICLE
5043    r"""
5044    When visited, one instance of type 'T' previously added to the route
5045    (TYPE_ADDED_TO_VEHICLE), if any, is removed from the vehicle.
5046    If the type was not previously added to the route or all added instances
5047    have already been removed, this visit has no effect on the types.
5048    """
5049    TYPE_ON_VEHICLE_UP_TO_VISIT = _pywrapcp.RoutingModel_TYPE_ON_VEHICLE_UP_TO_VISIT
5050    r"""
5051    With the following policy, the visit enforces that type 'T' is
5052    considered on the route from its start until this node is visited.
5053    """
5054    TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED = _pywrapcp.RoutingModel_TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED
5055    r"""
5056    The visit doesn't have an impact on the number of types 'T' on the
5057    route, as it's (virtually) added and removed directly.
5058    This policy can be used for visits which are part of an incompatibility
5059    or requirement set without affecting the type count on the route.
5060    """
5061
5062    def SetVisitType(self, index, type, type_policy):
5063        return _pywrapcp.RoutingModel_SetVisitType(self, index, type, type_policy)
5064
5065    def GetVisitType(self, index):
5066        return _pywrapcp.RoutingModel_GetVisitType(self, index)
5067
5068    def GetSingleNodesOfType(self, type):
5069        return _pywrapcp.RoutingModel_GetSingleNodesOfType(self, type)
5070
5071    def GetPairIndicesOfType(self, type):
5072        return _pywrapcp.RoutingModel_GetPairIndicesOfType(self, type)
5073
5074    def GetVisitTypePolicy(self, index):
5075        return _pywrapcp.RoutingModel_GetVisitTypePolicy(self, index)
5076
5077    def CloseVisitTypes(self):
5078        r"""
5079        This function should be called once all node visit types have been set and
5080        prior to adding any incompatibilities/requirements.
5081        "close" types.
5082        """
5083        return _pywrapcp.RoutingModel_CloseVisitTypes(self)
5084
5085    def GetNumberOfVisitTypes(self):
5086        return _pywrapcp.RoutingModel_GetNumberOfVisitTypes(self)
5087
5088    def AddHardTypeIncompatibility(self, type1, type2):
5089        r"""
5090        Incompatibilities:
5091        Two nodes with "hard" incompatible types cannot share the same route at
5092        all, while with a "temporal" incompatibility they can't be on the same
5093        route at the same time.
5094        """
5095        return _pywrapcp.RoutingModel_AddHardTypeIncompatibility(self, type1, type2)
5096
5097    def AddTemporalTypeIncompatibility(self, type1, type2):
5098        return _pywrapcp.RoutingModel_AddTemporalTypeIncompatibility(self, type1, type2)
5099
5100    def GetHardTypeIncompatibilitiesOfType(self, type):
5101        r""" Returns visit types incompatible with a given type."""
5102        return _pywrapcp.RoutingModel_GetHardTypeIncompatibilitiesOfType(self, type)
5103
5104    def GetTemporalTypeIncompatibilitiesOfType(self, type):
5105        return _pywrapcp.RoutingModel_GetTemporalTypeIncompatibilitiesOfType(self, type)
5106
5107    def HasHardTypeIncompatibilities(self):
5108        r"""
5109        Returns true iff any hard (resp. temporal) type incompatibilities have
5110        been added to the model.
5111        """
5112        return _pywrapcp.RoutingModel_HasHardTypeIncompatibilities(self)
5113
5114    def HasTemporalTypeIncompatibilities(self):
5115        return _pywrapcp.RoutingModel_HasTemporalTypeIncompatibilities(self)
5116
5117    def AddSameVehicleRequiredTypeAlternatives(self, dependent_type, required_type_alternatives):
5118        r"""
5119        Requirements:
5120        NOTE: As of 2019-04, cycles in the requirement graph are not supported,
5121        and lead to the dependent nodes being skipped if possible (otherwise
5122        the model is considered infeasible).
5123        The following functions specify that "dependent_type" requires at least
5124        one of the types in "required_type_alternatives".
5125
5126        For same-vehicle requirements, a node of dependent type type_D requires at
5127        least one node of type type_R among the required alternatives on the same
5128        route.
5129        """
5130        return _pywrapcp.RoutingModel_AddSameVehicleRequiredTypeAlternatives(self, dependent_type, required_type_alternatives)
5131
5132    def AddRequiredTypeAlternativesWhenAddingType(self, dependent_type, required_type_alternatives):
5133        r"""
5134        If type_D depends on type_R when adding type_D, any node_D of type_D and
5135        VisitTypePolicy TYPE_ADDED_TO_VEHICLE or
5136        TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED requires at least one type_R on its
5137        vehicle at the time node_D is visited.
5138        """
5139        return _pywrapcp.RoutingModel_AddRequiredTypeAlternativesWhenAddingType(self, dependent_type, required_type_alternatives)
5140
5141    def AddRequiredTypeAlternativesWhenRemovingType(self, dependent_type, required_type_alternatives):
5142        r"""
5143        The following requirements apply when visiting dependent nodes that remove
5144        their type from the route, i.e. type_R must be on the vehicle when type_D
5145        of VisitTypePolicy ADDED_TYPE_REMOVED_FROM_VEHICLE,
5146        TYPE_ON_VEHICLE_UP_TO_VISIT or TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED is
5147        visited.
5148        """
5149        return _pywrapcp.RoutingModel_AddRequiredTypeAlternativesWhenRemovingType(self, dependent_type, required_type_alternatives)
5150
5151    def GetSameVehicleRequiredTypeAlternativesOfType(self, type):
5152        r"""
5153        Returns the set of same-vehicle requirement alternatives for the given
5154        type.
5155        """
5156        return _pywrapcp.RoutingModel_GetSameVehicleRequiredTypeAlternativesOfType(self, type)
5157
5158    def GetRequiredTypeAlternativesWhenAddingType(self, type):
5159        r""" Returns the set of requirement alternatives when adding the given type."""
5160        return _pywrapcp.RoutingModel_GetRequiredTypeAlternativesWhenAddingType(self, type)
5161
5162    def GetRequiredTypeAlternativesWhenRemovingType(self, type):
5163        r""" Returns the set of requirement alternatives when removing the given type."""
5164        return _pywrapcp.RoutingModel_GetRequiredTypeAlternativesWhenRemovingType(self, type)
5165
5166    def HasSameVehicleTypeRequirements(self):
5167        r"""
5168        Returns true iff any same-route (resp. temporal) type requirements have
5169        been added to the model.
5170        """
5171        return _pywrapcp.RoutingModel_HasSameVehicleTypeRequirements(self)
5172
5173    def HasTemporalTypeRequirements(self):
5174        return _pywrapcp.RoutingModel_HasTemporalTypeRequirements(self)
5175
5176    def HasTypeRegulations(self):
5177        r"""
5178        Returns true iff the model has any incompatibilities or requirements set
5179        on node types.
5180        """
5181        return _pywrapcp.RoutingModel_HasTypeRegulations(self)
5182
5183    def UnperformedPenalty(self, var_index):
5184        r"""
5185        Get the "unperformed" penalty of a node. This is only well defined if the
5186        node is only part of a single Disjunction, and that disjunction has a
5187        penalty. For forced active nodes returns max int64_t. In all other cases,
5188        this returns 0.
5189        """
5190        return _pywrapcp.RoutingModel_UnperformedPenalty(self, var_index)
5191
5192    def UnperformedPenaltyOrValue(self, default_value, var_index):
5193        r"""
5194        Same as above except that it returns default_value instead of 0 when
5195        penalty is not well defined (default value is passed as first argument to
5196        simplify the usage of the method in a callback).
5197        """
5198        return _pywrapcp.RoutingModel_UnperformedPenaltyOrValue(self, default_value, var_index)
5199
5200    def GetDepot(self):
5201        r"""
5202        Returns the variable index of the first starting or ending node of all
5203        routes. If all routes start  and end at the same node (single depot), this
5204        is the node returned.
5205        """
5206        return _pywrapcp.RoutingModel_GetDepot(self)
5207
5208    def SetMaximumNumberOfActiveVehicles(self, max_active_vehicles):
5209        r"""
5210        Constrains the maximum number of active vehicles, aka the number of
5211        vehicles which do not have an empty route. For instance, this can be used
5212        to limit the number of routes in the case where there are fewer drivers
5213        than vehicles and that the fleet of vehicle is heterogeneous.
5214        """
5215        return _pywrapcp.RoutingModel_SetMaximumNumberOfActiveVehicles(self, max_active_vehicles)
5216
5217    def GetMaximumNumberOfActiveVehicles(self):
5218        r""" Returns the maximum number of active vehicles."""
5219        return _pywrapcp.RoutingModel_GetMaximumNumberOfActiveVehicles(self)
5220
5221    def SetArcCostEvaluatorOfAllVehicles(self, evaluator_index):
5222        r"""
5223        Sets the cost function of the model such that the cost of a segment of a
5224        route between node 'from' and 'to' is evaluator(from, to), whatever the
5225        route or vehicle performing the route.
5226        """
5227        return _pywrapcp.RoutingModel_SetArcCostEvaluatorOfAllVehicles(self, evaluator_index)
5228
5229    def SetArcCostEvaluatorOfVehicle(self, evaluator_index, vehicle):
5230        r""" Sets the cost function for a given vehicle route."""
5231        return _pywrapcp.RoutingModel_SetArcCostEvaluatorOfVehicle(self, evaluator_index, vehicle)
5232
5233    def SetFixedCostOfAllVehicles(self, cost):
5234        r"""
5235        Sets the fixed cost of all vehicle routes. It is equivalent to calling
5236        SetFixedCostOfVehicle on all vehicle routes.
5237        """
5238        return _pywrapcp.RoutingModel_SetFixedCostOfAllVehicles(self, cost)
5239
5240    def SetFixedCostOfVehicle(self, cost, vehicle):
5241        r""" Sets the fixed cost of one vehicle route."""
5242        return _pywrapcp.RoutingModel_SetFixedCostOfVehicle(self, cost, vehicle)
5243
5244    def GetFixedCostOfVehicle(self, vehicle):
5245        r"""
5246        Returns the route fixed cost taken into account if the route of the
5247        vehicle is not empty, aka there's at least one node on the route other
5248        than the first and last nodes.
5249        """
5250        return _pywrapcp.RoutingModel_GetFixedCostOfVehicle(self, vehicle)
5251
5252    def SetPathEnergyCostOfVehicle(self, force, distance, unit_cost, vehicle):
5253        return _pywrapcp.RoutingModel_SetPathEnergyCostOfVehicle(self, force, distance, unit_cost, vehicle)
5254
5255    def SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor, quadratic_cost_factor):
5256        r"""
5257        The following methods set the linear and quadratic cost factors of
5258        vehicles (must be positive values). The default value of these parameters
5259        is zero for all vehicles.
5260
5261        When set, the cost_ of the model will contain terms aiming at reducing the
5262        number of vehicles used in the model, by adding the following to the
5263        objective for every vehicle v:
5264        INDICATOR(v used in the model) *
5265          [linear_cost_factor_of_vehicle_[v]
5266           - quadratic_cost_factor_of_vehicle_[v]*(square of length of route v)]
5267        i.e. for every used vehicle, we add the linear factor as fixed cost, and
5268        subtract the square of the route length multiplied by the quadratic
5269        factor. This second term aims at making the routes as dense as possible.
5270
5271        Sets the linear and quadratic cost factor of all vehicles.
5272        """
5273        return _pywrapcp.RoutingModel_SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor, quadratic_cost_factor)
5274
5275    def SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor, quadratic_cost_factor, vehicle):
5276        r""" Sets the linear and quadratic cost factor of the given vehicle."""
5277        return _pywrapcp.RoutingModel_SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor, quadratic_cost_factor, vehicle)
5278
5279    def GetAmortizedLinearCostFactorOfVehicles(self):
5280        return _pywrapcp.RoutingModel_GetAmortizedLinearCostFactorOfVehicles(self)
5281
5282    def GetAmortizedQuadraticCostFactorOfVehicles(self):
5283        return _pywrapcp.RoutingModel_GetAmortizedQuadraticCostFactorOfVehicles(self)
5284
5285    def SetVehicleUsedWhenEmpty(self, is_used, vehicle):
5286        return _pywrapcp.RoutingModel_SetVehicleUsedWhenEmpty(self, is_used, vehicle)
5287
5288    def IsVehicleUsedWhenEmpty(self, vehicle):
5289        return _pywrapcp.RoutingModel_IsVehicleUsedWhenEmpty(self, vehicle)
5290
5291    def SetFirstSolutionEvaluator(self, evaluator):
5292        r"""
5293        Gets/sets the evaluator used during the search. Only relevant when
5294        RoutingSearchParameters.first_solution_strategy = EVALUATOR_STRATEGY.
5295        Takes ownership of evaluator.
5296        """
5297        return _pywrapcp.RoutingModel_SetFirstSolutionEvaluator(self, evaluator)
5298
5299    def AddLocalSearchOperator(self, ls_operator):
5300        r"""
5301        Adds a local search operator to the set of operators used to solve the
5302        vehicle routing problem.
5303        """
5304        return _pywrapcp.RoutingModel_AddLocalSearchOperator(self, ls_operator)
5305
5306    def AddSearchMonitor(self, monitor):
5307        r""" Adds a search monitor to the search used to solve the routing model."""
5308        return _pywrapcp.RoutingModel_AddSearchMonitor(self, monitor)
5309
5310    def AddAtSolutionCallback(self, callback, track_unchecked_neighbors=False):
5311        r"""
5312        Adds a callback called each time a solution is found during the search.
5313        This is a shortcut to creating a monitor to call the callback on
5314        AtSolution() and adding it with AddSearchMonitor.
5315        If track_unchecked_neighbors is true, the callback will also be called on
5316        AcceptUncheckedNeighbor() events, which is useful to grab solutions
5317        obtained when solver_parameters.check_solution_period > 1 (aka fastLS).
5318        """
5319        return _pywrapcp.RoutingModel_AddAtSolutionCallback(self, callback, track_unchecked_neighbors)
5320
5321    def AddVariableMinimizedByFinalizer(self, var):
5322        r"""
5323        Adds a variable to minimize in the solution finalizer. The solution
5324        finalizer is called each time a solution is found during the search and
5325        allows to instantiate secondary variables (such as dimension cumul
5326        variables).
5327        """
5328        return _pywrapcp.RoutingModel_AddVariableMinimizedByFinalizer(self, var)
5329
5330    def AddVariableMaximizedByFinalizer(self, var):
5331        r"""
5332        Adds a variable to maximize in the solution finalizer (see above for
5333        information on the solution finalizer).
5334        """
5335        return _pywrapcp.RoutingModel_AddVariableMaximizedByFinalizer(self, var)
5336
5337    def AddWeightedVariableMinimizedByFinalizer(self, var, cost):
5338        r"""
5339        Adds a variable to minimize in the solution finalizer, with a weighted
5340        priority: the higher the more priority it has.
5341        """
5342        return _pywrapcp.RoutingModel_AddWeightedVariableMinimizedByFinalizer(self, var, cost)
5343
5344    def AddWeightedVariableMaximizedByFinalizer(self, var, cost):
5345        r"""
5346        Adds a variable to maximize in the solution finalizer, with a weighted
5347        priority: the higher the more priority it has.
5348        """
5349        return _pywrapcp.RoutingModel_AddWeightedVariableMaximizedByFinalizer(self, var, cost)
5350
5351    def AddVariableTargetToFinalizer(self, var, target):
5352        r"""
5353        Add a variable to set the closest possible to the target value in the
5354        solution finalizer.
5355        """
5356        return _pywrapcp.RoutingModel_AddVariableTargetToFinalizer(self, var, target)
5357
5358    def AddWeightedVariableTargetToFinalizer(self, var, target, cost):
5359        r"""
5360        Same as above with a weighted priority: the higher the cost, the more
5361        priority it has to be set close to the target value.
5362        """
5363        return _pywrapcp.RoutingModel_AddWeightedVariableTargetToFinalizer(self, var, target, cost)
5364
5365    def CloseModel(self):
5366        r"""
5367        Closes the current routing model; after this method is called, no
5368        modification to the model can be done, but RoutesToAssignment becomes
5369        available. Note that CloseModel() is automatically called by Solve() and
5370        other methods that produce solution.
5371        This is equivalent to calling
5372        CloseModelWithParameters(DefaultRoutingSearchParameters()).
5373        """
5374        return _pywrapcp.RoutingModel_CloseModel(self)
5375
5376    def CloseModelWithParameters(self, search_parameters):
5377        r"""
5378        Same as above taking search parameters (as of 10/2015 some the parameters
5379        have to be set when closing the model).
5380        """
5381        return _pywrapcp.RoutingModel_CloseModelWithParameters(self, search_parameters)
5382
5383    def Solve(self, assignment=None):
5384        r"""
5385        Solves the current routing model; closes the current model.
5386        This is equivalent to calling
5387        SolveWithParameters(DefaultRoutingSearchParameters())
5388        or
5389        SolveFromAssignmentWithParameters(assignment,
5390                                          DefaultRoutingSearchParameters()).
5391        """
5392        return _pywrapcp.RoutingModel_Solve(self, assignment)
5393
5394    def SolveWithParameters(self, search_parameters, solutions=None):
5395        r"""
5396        Solves the current routing model with the given parameters. If 'solutions'
5397        is specified, it will contain the k best solutions found during the search
5398        (from worst to best, including the one returned by this method), where k
5399        corresponds to the 'number_of_solutions_to_collect' in
5400        'search_parameters'. Note that the Assignment returned by the method and
5401        the ones in solutions are owned by the underlying solver and should not be
5402        deleted.
5403        """
5404        return _pywrapcp.RoutingModel_SolveWithParameters(self, search_parameters, solutions)
5405
5406    def SolveFromAssignmentWithParameters(self, assignment, search_parameters, solutions=None):
5407        r"""
5408        Same as above, except that if assignment is not null, it will be used as
5409        the initial solution.
5410        """
5411        return _pywrapcp.RoutingModel_SolveFromAssignmentWithParameters(self, assignment, search_parameters, solutions)
5412
5413    def SolveFromAssignmentsWithParameters(self, assignments, search_parameters, solutions=None):
5414        r"""
5415        Same as above but will try all assignments in order as first solutions
5416        until one succeeds.
5417        """
5418        return _pywrapcp.RoutingModel_SolveFromAssignmentsWithParameters(self, assignments, search_parameters, solutions)
5419
5420    def SetAssignmentFromOtherModelAssignment(self, target_assignment, source_model, source_assignment):
5421        r"""
5422        Given a "source_model" and its "source_assignment", resets
5423        "target_assignment" with the IntVar variables (nexts_, and vehicle_vars_
5424        if costs aren't homogeneous across vehicles) of "this" model, with the
5425        values set according to those in "other_assignment".
5426        The objective_element of target_assignment is set to this->cost_.
5427        """
5428        return _pywrapcp.RoutingModel_SetAssignmentFromOtherModelAssignment(self, target_assignment, source_model, source_assignment)
5429
5430    def ComputeLowerBound(self):
5431        r"""
5432        Computes a lower bound to the routing problem solving a linear assignment
5433        problem. The routing model must be closed before calling this method.
5434        Note that problems with node disjunction constraints (including optional
5435        nodes) and non-homogenous costs are not supported (the method returns 0 in
5436        these cases).
5437        """
5438        return _pywrapcp.RoutingModel_ComputeLowerBound(self)
5439
5440    def status(self):
5441        r""" Returns the current status of the routing model."""
5442        return _pywrapcp.RoutingModel_status(self)
5443
5444    def enable_deep_serialization(self):
5445        r""" Returns the value of the internal enable_deep_serialization_ parameter."""
5446        return _pywrapcp.RoutingModel_enable_deep_serialization(self)
5447
5448    def ApplyLocks(self, locks):
5449        r"""
5450        Applies a lock chain to the next search. 'locks' represents an ordered
5451        vector of nodes representing a partial route which will be fixed during
5452        the next search; it will constrain next variables such that:
5453        next[locks[i]] == locks[i+1].
5454
5455        Returns the next variable at the end of the locked chain; this variable is
5456        not locked. An assignment containing the locks can be obtained by calling
5457        PreAssignment().
5458        """
5459        return _pywrapcp.RoutingModel_ApplyLocks(self, locks)
5460
5461    def ApplyLocksToAllVehicles(self, locks, close_routes):
5462        r"""
5463        Applies lock chains to all vehicles to the next search, such that locks[p]
5464        is the lock chain for route p. Returns false if the locks do not contain
5465        valid routes; expects that the routes do not contain the depots,
5466        i.e. there are empty vectors in place of empty routes.
5467        If close_routes is set to true, adds the end nodes to the route of each
5468        vehicle and deactivates other nodes.
5469        An assignment containing the locks can be obtained by calling
5470        PreAssignment().
5471        """
5472        return _pywrapcp.RoutingModel_ApplyLocksToAllVehicles(self, locks, close_routes)
5473
5474    def PreAssignment(self):
5475        r"""
5476        Returns an assignment used to fix some of the variables of the problem.
5477        In practice, this assignment locks partial routes of the problem. This
5478        can be used in the context of locking the parts of the routes which have
5479        already been driven in online routing problems.
5480        """
5481        return _pywrapcp.RoutingModel_PreAssignment(self)
5482
5483    def MutablePreAssignment(self):
5484        return _pywrapcp.RoutingModel_MutablePreAssignment(self)
5485
5486    def WriteAssignment(self, file_name):
5487        r"""
5488        Writes the current solution to a file containing an AssignmentProto.
5489        Returns false if the file cannot be opened or if there is no current
5490        solution.
5491        """
5492        return _pywrapcp.RoutingModel_WriteAssignment(self, file_name)
5493
5494    def ReadAssignment(self, file_name):
5495        r"""
5496        Reads an assignment from a file and returns the current solution.
5497        Returns nullptr if the file cannot be opened or if the assignment is not
5498        valid.
5499        """
5500        return _pywrapcp.RoutingModel_ReadAssignment(self, file_name)
5501
5502    def RestoreAssignment(self, solution):
5503        r"""
5504        Restores an assignment as a solution in the routing model and returns the
5505        new solution. Returns nullptr if the assignment is not valid.
5506        """
5507        return _pywrapcp.RoutingModel_RestoreAssignment(self, solution)
5508
5509    def ReadAssignmentFromRoutes(self, routes, ignore_inactive_indices):
5510        r"""
5511        Restores the routes as the current solution. Returns nullptr if the
5512        solution cannot be restored (routes do not contain a valid solution). Note
5513        that calling this method will run the solver to assign values to the
5514        dimension variables; this may take considerable amount of time, especially
5515        when using dimensions with slack.
5516        """
5517        return _pywrapcp.RoutingModel_ReadAssignmentFromRoutes(self, routes, ignore_inactive_indices)
5518
5519    def RoutesToAssignment(self, routes, ignore_inactive_indices, close_routes, assignment):
5520        r"""
5521        Fills an assignment from a specification of the routes of the
5522        vehicles. The routes are specified as lists of variable indices that
5523        appear on the routes of the vehicles. The indices of the outer vector in
5524        'routes' correspond to vehicles IDs, the inner vector contains the
5525        variable indices on the routes for the given vehicle. The inner vectors
5526        must not contain the start and end indices, as these are determined by the
5527        routing model.  Sets the value of NextVars in the assignment, adding the
5528        variables to the assignment if necessary. The method does not touch other
5529        variables in the assignment. The method can only be called after the model
5530        is closed.  With ignore_inactive_indices set to false, this method will
5531        fail (return nullptr) in case some of the route contain indices that are
5532        deactivated in the model; when set to true, these indices will be
5533        skipped.  Returns true if routes were successfully
5534        loaded. However, such assignment still might not be a valid
5535        solution to the routing problem due to more complex constraints;
5536        it is advisible to call solver()->CheckSolution() afterwards.
5537        """
5538        return _pywrapcp.RoutingModel_RoutesToAssignment(self, routes, ignore_inactive_indices, close_routes, assignment)
5539
5540    def AssignmentToRoutes(self, assignment, routes):
5541        r"""
5542        Converts the solution in the given assignment to routes for all vehicles.
5543        Expects that assignment contains a valid solution (i.e. routes for all
5544        vehicles end with an end index for that vehicle).
5545        """
5546        return _pywrapcp.RoutingModel_AssignmentToRoutes(self, assignment, routes)
5547
5548    def CompactAssignment(self, assignment):
5549        r"""
5550        Converts the solution in the given assignment to routes for all vehicles.
5551        If the returned vector is route_indices, route_indices[i][j] is the index
5552        for jth location visited on route i. Note that contrary to
5553        AssignmentToRoutes, the vectors do include start and end locations.
5554        Returns a compacted version of the given assignment, in which all vehicles
5555        with id lower or equal to some N have non-empty routes, and all vehicles
5556        with id greater than N have empty routes. Does not take ownership of the
5557        returned object.
5558        If found, the cost of the compact assignment is the same as in the
5559        original assignment and it preserves the values of 'active' variables.
5560        Returns nullptr if a compact assignment was not found.
5561        This method only works in homogenous mode, and it only swaps equivalent
5562        vehicles (vehicles with the same start and end nodes). When creating the
5563        compact assignment, the empty plan is replaced by the route assigned to
5564        the compatible vehicle with the highest id. Note that with more complex
5565        constraints on vehicle variables, this method might fail even if a compact
5566        solution exists.
5567        This method changes the vehicle and dimension variables as necessary.
5568        While compacting the solution, only basic checks on vehicle variables are
5569        performed; if one of these checks fails no attempts to repair it are made
5570        (instead, the method returns nullptr).
5571        """
5572        return _pywrapcp.RoutingModel_CompactAssignment(self, assignment)
5573
5574    def CompactAndCheckAssignment(self, assignment):
5575        r"""
5576        Same as CompactAssignment() but also checks the validity of the final
5577        compact solution; if it is not valid, no attempts to repair it are made
5578        (instead, the method returns nullptr).
5579        """
5580        return _pywrapcp.RoutingModel_CompactAndCheckAssignment(self, assignment)
5581
5582    def AddToAssignment(self, var):
5583        r""" Adds an extra variable to the vehicle routing assignment."""
5584        return _pywrapcp.RoutingModel_AddToAssignment(self, var)
5585
5586    def AddIntervalToAssignment(self, interval):
5587        return _pywrapcp.RoutingModel_AddIntervalToAssignment(self, interval)
5588
5589    def PackCumulsOfOptimizerDimensionsFromAssignment(self, original_assignment, duration_limit, time_limit_was_reached=None):
5590        r"""
5591        For every dimension in the model with an optimizer in
5592        local/global_dimension_optimizers_, this method tries to pack the cumul
5593        values of the dimension, such that:
5594        - The cumul costs (span costs, soft lower and upper bound costs, etc) are
5595          minimized.
5596        - The cumuls of the ends of the routes are minimized for this given
5597          minimal cumul cost.
5598        - Given these minimal end cumuls, the route start cumuls are maximized.
5599        Returns the assignment resulting from allocating these packed cumuls with
5600        the solver, and nullptr if these cumuls could not be set by the solver.
5601        """
5602        return _pywrapcp.RoutingModel_PackCumulsOfOptimizerDimensionsFromAssignment(self, original_assignment, duration_limit, time_limit_was_reached)
5603
5604    def GetOrCreateNodeNeighborsByCostClass(self, *args):
5605        r"""
5606        *Overload 1:*
5607        Returns neighbors of all nodes for every cost class. The result is cached
5608        and is computed once. The number of neighbors considered is based on a
5609        ratio of non-vehicle nodes, specified by neighbors_ratio, with a minimum
5610        of min-neighbors node considered.
5611
5612        |
5613
5614        *Overload 2:*
5615        Returns parameters.num_neighbors neighbors of all nodes for every cost
5616        class. The result is cached and is computed once.
5617
5618        |
5619
5620        *Overload 3:*
5621        Returns parameters.num_neighbors neighbors of all nodes for every cost
5622        class. The result is cached and is computed once.
5623        """
5624        return _pywrapcp.RoutingModel_GetOrCreateNodeNeighborsByCostClass(self, *args)
5625
5626    def AddLocalSearchFilter(self, filter):
5627        r"""
5628        Adds a custom local search filter to the list of filters used to speed up
5629        local search by pruning unfeasible variable assignments.
5630        Calling this method after the routing model has been closed (CloseModel()
5631        or Solve() has been called) has no effect.
5632        The routing model does not take ownership of the filter.
5633        """
5634        return _pywrapcp.RoutingModel_AddLocalSearchFilter(self, filter)
5635
5636    def Start(self, vehicle):
5637        r"""
5638        Model inspection.
5639        Returns the variable index of the starting node of a vehicle route.
5640        """
5641        return _pywrapcp.RoutingModel_Start(self, vehicle)
5642
5643    def End(self, vehicle):
5644        r""" Returns the variable index of the ending node of a vehicle route."""
5645        return _pywrapcp.RoutingModel_End(self, vehicle)
5646
5647    def IsStart(self, index):
5648        r""" Returns true if 'index' represents the first node of a route."""
5649        return _pywrapcp.RoutingModel_IsStart(self, index)
5650
5651    def IsEnd(self, index):
5652        r""" Returns true if 'index' represents the last node of a route."""
5653        return _pywrapcp.RoutingModel_IsEnd(self, index)
5654
5655    def VehicleIndex(self, index):
5656        r"""
5657        Returns the vehicle of the given start/end index, and -1 if the given
5658        index is not a vehicle start/end.
5659        """
5660        return _pywrapcp.RoutingModel_VehicleIndex(self, index)
5661
5662    def Next(self, assignment, index):
5663        r"""
5664        Assignment inspection
5665        Returns the variable index of the node directly after the node
5666        corresponding to 'index' in 'assignment'.
5667        """
5668        return _pywrapcp.RoutingModel_Next(self, assignment, index)
5669
5670    def IsVehicleUsed(self, assignment, vehicle):
5671        r""" Returns true if the route of 'vehicle' is non empty in 'assignment'."""
5672        return _pywrapcp.RoutingModel_IsVehicleUsed(self, assignment, vehicle)
5673
5674    def NextVar(self, index):
5675        r"""
5676        Returns the next variable of the node corresponding to index. Note that
5677        NextVar(index) == index is equivalent to ActiveVar(index) == 0.
5678        """
5679        return _pywrapcp.RoutingModel_NextVar(self, index)
5680
5681    def ActiveVar(self, index):
5682        r""" Returns the active variable of the node corresponding to index."""
5683        return _pywrapcp.RoutingModel_ActiveVar(self, index)
5684
5685    def ActiveVehicleVar(self, vehicle):
5686        r"""
5687        Returns the active variable of the vehicle. It will be equal to 1 iff the
5688        route of the vehicle is not empty, 0 otherwise.
5689        """
5690        return _pywrapcp.RoutingModel_ActiveVehicleVar(self, vehicle)
5691
5692    def VehicleRouteConsideredVar(self, vehicle):
5693        r"""
5694        Returns the variable specifying whether or not the given vehicle route is
5695        considered for costs and constraints. It will be equal to 1 iff the route
5696        of the vehicle is not empty OR vehicle_used_when_empty_[vehicle] is true.
5697        """
5698        return _pywrapcp.RoutingModel_VehicleRouteConsideredVar(self, vehicle)
5699
5700    def VehicleVar(self, index):
5701        r"""
5702        Returns the vehicle variable of the node corresponding to index. Note that
5703        VehicleVar(index) == -1 is equivalent to ActiveVar(index) == 0.
5704        """
5705        return _pywrapcp.RoutingModel_VehicleVar(self, index)
5706
5707    def ResourceVar(self, vehicle, resource_group):
5708        r"""
5709        Returns the resource variable for the given vehicle index in the given
5710        resource group. If a vehicle doesn't require a resource from the
5711        corresponding resource group, then ResourceVar(v, r_g) == -1.
5712        """
5713        return _pywrapcp.RoutingModel_ResourceVar(self, vehicle, resource_group)
5714
5715    def CostVar(self):
5716        r""" Returns the global cost variable which is being minimized."""
5717        return _pywrapcp.RoutingModel_CostVar(self)
5718
5719    def GetArcCostForVehicle(self, from_index, to_index, vehicle):
5720        r"""
5721        Returns the cost of the transit arc between two nodes for a given vehicle.
5722        Input are variable indices of node. This returns 0 if vehicle < 0.
5723        """
5724        return _pywrapcp.RoutingModel_GetArcCostForVehicle(self, from_index, to_index, vehicle)
5725
5726    def CostsAreHomogeneousAcrossVehicles(self):
5727        r""" Whether costs are homogeneous across all vehicles."""
5728        return _pywrapcp.RoutingModel_CostsAreHomogeneousAcrossVehicles(self)
5729
5730    def GetHomogeneousCost(self, from_index, to_index):
5731        r"""
5732        Returns the cost of the segment between two nodes supposing all vehicle
5733        costs are the same (returns the cost for the first vehicle otherwise).
5734        """
5735        return _pywrapcp.RoutingModel_GetHomogeneousCost(self, from_index, to_index)
5736
5737    def GetArcCostForFirstSolution(self, from_index, to_index):
5738        r"""
5739        Returns the cost of the arc in the context of the first solution strategy.
5740        This is typically a simplification of the actual cost; see the .cc.
5741        """
5742        return _pywrapcp.RoutingModel_GetArcCostForFirstSolution(self, from_index, to_index)
5743
5744    def GetArcCostForClass(self, from_index, to_index, cost_class_index):
5745        r"""
5746        Returns the cost of the segment between two nodes for a given cost
5747        class. Input are variable indices of nodes and the cost class.
5748        Unlike GetArcCostForVehicle(), if cost_class is kNoCost, then the
5749        returned cost won't necessarily be zero: only some of the components
5750        of the cost that depend on the cost class will be omited. See the code
5751        for details.
5752        """
5753        return _pywrapcp.RoutingModel_GetArcCostForClass(self, from_index, to_index, cost_class_index)
5754
5755    def GetCostClassIndexOfVehicle(self, vehicle):
5756        r""" Get the cost class index of the given vehicle."""
5757        return _pywrapcp.RoutingModel_GetCostClassIndexOfVehicle(self, vehicle)
5758
5759    def HasVehicleWithCostClassIndex(self, cost_class_index):
5760        r"""
5761        Returns true iff the model contains a vehicle with the given
5762        cost_class_index.
5763        """
5764        return _pywrapcp.RoutingModel_HasVehicleWithCostClassIndex(self, cost_class_index)
5765
5766    def GetCostClassesCount(self):
5767        r""" Returns the number of different cost classes in the model."""
5768        return _pywrapcp.RoutingModel_GetCostClassesCount(self)
5769
5770    def GetNonZeroCostClassesCount(self):
5771        r""" Ditto, minus the 'always zero', built-in cost class."""
5772        return _pywrapcp.RoutingModel_GetNonZeroCostClassesCount(self)
5773
5774    def GetVehicleClassIndexOfVehicle(self, vehicle):
5775        return _pywrapcp.RoutingModel_GetVehicleClassIndexOfVehicle(self, vehicle)
5776
5777    def GetVehicleOfClass(self, vehicle_class):
5778        r"""
5779        Returns a vehicle of the given vehicle class, and -1 if there are no
5780        vehicles for this class.
5781        """
5782        return _pywrapcp.RoutingModel_GetVehicleOfClass(self, vehicle_class)
5783
5784    def GetVehicleClassesCount(self):
5785        r""" Returns the number of different vehicle classes in the model."""
5786        return _pywrapcp.RoutingModel_GetVehicleClassesCount(self)
5787
5788    def GetSameVehicleIndicesOfIndex(self, node):
5789        r""" Returns variable indices of nodes constrained to be on the same route."""
5790        return _pywrapcp.RoutingModel_GetSameVehicleIndicesOfIndex(self, node)
5791
5792    def GetVehicleTypeContainer(self):
5793        return _pywrapcp.RoutingModel_GetVehicleTypeContainer(self)
5794
5795    def ArcIsMoreConstrainedThanArc(self, _from, to1, to2):
5796        r"""
5797        Returns whether the arc from->to1 is more constrained than from->to2,
5798        taking into account, in order:
5799        - whether the destination node isn't an end node
5800        - whether the destination node is mandatory
5801        - whether the destination node is bound to the same vehicle as the source
5802        - the "primary constrained" dimension (see SetPrimaryConstrainedDimension)
5803        It then breaks ties using, in order:
5804        - the arc cost (taking unperformed penalties into account)
5805        - the size of the vehicle vars of "to1" and "to2" (lowest size wins)
5806        - the value: the lowest value of the indices to1 and to2 wins.
5807        See the .cc for details.
5808        The more constrained arc is typically preferable when building a
5809        first solution. This method is intended to be used as a callback for the
5810        BestValueByComparisonSelector value selector.
5811        Args:
5812          from: the variable index of the source node
5813          to1: the variable index of the first candidate destination node.
5814          to2: the variable index of the second candidate destination node.
5815        """
5816        return _pywrapcp.RoutingModel_ArcIsMoreConstrainedThanArc(self, _from, to1, to2)
5817
5818    def DebugOutputAssignment(self, solution_assignment, dimension_to_print):
5819        r"""
5820        Print some debugging information about an assignment, including the
5821        feasible intervals of the CumulVar for dimension "dimension_to_print"
5822        at each step of the routes.
5823        If "dimension_to_print" is omitted, all dimensions will be printed.
5824        """
5825        return _pywrapcp.RoutingModel_DebugOutputAssignment(self, solution_assignment, dimension_to_print)
5826
5827    def solver(self):
5828        r"""
5829        Returns a vector cumul_bounds, for which cumul_bounds[i][j] is a pair
5830        containing the minimum and maximum of the CumulVar of the jth node on
5831        route i.
5832        - cumul_bounds[i][j].first is the minimum.
5833        - cumul_bounds[i][j].second is the maximum.
5834        Returns the underlying constraint solver. Can be used to add extra
5835        constraints and/or modify search algorithms.
5836        """
5837        return _pywrapcp.RoutingModel_solver(self)
5838
5839    def CheckLimit(self, *args):
5840        r"""
5841        Returns true if the search limit has been crossed with the given time
5842        offset.
5843        """
5844        return _pywrapcp.RoutingModel_CheckLimit(self, *args)
5845
5846    def RemainingTime(self):
5847        r""" Returns the time left in the search limit."""
5848        return _pywrapcp.RoutingModel_RemainingTime(self)
5849
5850    def TimeBuffer(self):
5851        r""" Returns the time buffer to safely return a solution."""
5852        return _pywrapcp.RoutingModel_TimeBuffer(self)
5853
5854    def nodes(self):
5855        r"""
5856        Sizes and indices
5857        Returns the number of nodes in the model.
5858        """
5859        return _pywrapcp.RoutingModel_nodes(self)
5860
5861    def vehicles(self):
5862        r""" Returns the number of vehicle routes in the model."""
5863        return _pywrapcp.RoutingModel_vehicles(self)
5864
5865    def Size(self):
5866        r""" Returns the number of next variables in the model."""
5867        return _pywrapcp.RoutingModel_Size(self)
5868
5869    def GetNumberOfDecisionsInFirstSolution(self, search_parameters):
5870        r"""
5871        Returns statistics on first solution search, number of decisions sent to
5872        filters, number of decisions rejected by filters.
5873        """
5874        return _pywrapcp.RoutingModel_GetNumberOfDecisionsInFirstSolution(self, search_parameters)
5875
5876    def GetNumberOfRejectsInFirstSolution(self, search_parameters):
5877        return _pywrapcp.RoutingModel_GetNumberOfRejectsInFirstSolution(self, search_parameters)
5878
5879    def GetAutomaticFirstSolutionStrategy(self):
5880        r""" Returns the automatic first solution strategy selected."""
5881        return _pywrapcp.RoutingModel_GetAutomaticFirstSolutionStrategy(self)
5882
5883    def IsMatchingModel(self):
5884        r""" Returns true if a vehicle/node matching problem is detected."""
5885        return _pywrapcp.RoutingModel_IsMatchingModel(self)
5886
5887    def AreRoutesInterdependent(self, parameters):
5888        r"""
5889        Returns true if routes are interdependent. This means that any
5890        modification to a route might impact another.
5891        """
5892        return _pywrapcp.RoutingModel_AreRoutesInterdependent(self, parameters)
5893
5894    def MakeGuidedSlackFinalizer(self, dimension, initializer):
5895        r"""
5896        The next few members are in the public section only for testing purposes.
5897
5898        MakeGuidedSlackFinalizer creates a DecisionBuilder for the slacks of a
5899        dimension using a callback to choose which values to start with.
5900        The finalizer works only when all next variables in the model have
5901        been fixed. It has the following two characteristics:
5902        1. It follows the routes defined by the nexts variables when choosing a
5903           variable to make a decision on.
5904        2. When it comes to choose a value for the slack of node i, the decision
5905           builder first calls the callback with argument i, and supposingly the
5906           returned value is x it creates decisions slack[i] = x, slack[i] = x +
5907           1, slack[i] = x - 1, slack[i] = x + 2, etc.
5908        """
5909        return _pywrapcp.RoutingModel_MakeGuidedSlackFinalizer(self, dimension, initializer)
5910
5911    def MakeSelfDependentDimensionFinalizer(self, dimension):
5912        r"""
5913        MakeSelfDependentDimensionFinalizer is a finalizer for the slacks of a
5914        self-dependent dimension. It makes an extensive use of the caches of the
5915        state dependent transits.
5916        In detail, MakeSelfDependentDimensionFinalizer returns a composition of a
5917        local search decision builder with a greedy descent operator for the cumul
5918        of the start of each route and a guided slack finalizer. Provided there
5919        are no time windows and the maximum slacks are large enough, once the
5920        cumul of the start of route is fixed, the guided finalizer can find
5921        optimal values of the slacks for the rest of the route in time
5922        proportional to the length of the route. Therefore the composed finalizer
5923        generally works in time O(log(t)*n*m), where t is the latest possible
5924        departute time, n is the number of nodes in the network and m is the
5925        number of vehicles.
5926        """
5927        return _pywrapcp.RoutingModel_MakeSelfDependentDimensionFinalizer(self, dimension)
5928
5929    def GetPathsMetadata(self):
5930        return _pywrapcp.RoutingModel_GetPathsMetadata(self)
5931
5932# Register RoutingModel in _pywrapcp:
5933_pywrapcp.RoutingModel_swigregister(RoutingModel)
5934cvar = _pywrapcp.cvar
5935RoutingModel.kNoPenalty = _pywrapcp.cvar.RoutingModel_kNoPenalty
5936RoutingModel.kNoDisjunction = _pywrapcp.cvar.RoutingModel_kNoDisjunction
5937RoutingModel.kNoDimension = _pywrapcp.cvar.RoutingModel_kNoDimension
5938
5939class RoutingModelVisitor(BaseObject):
5940    r""" Routing model visitor."""
5941
5942    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5943    __repr__ = _swig_repr
5944
5945    def __init__(self):
5946        _pywrapcp.RoutingModelVisitor_swiginit(self, _pywrapcp.new_RoutingModelVisitor())
5947    __swig_destroy__ = _pywrapcp.delete_RoutingModelVisitor
5948
5949# Register RoutingModelVisitor in _pywrapcp:
5950_pywrapcp.RoutingModelVisitor_swigregister(RoutingModelVisitor)
5951RoutingModelVisitor.kLightElement = _pywrapcp.cvar.RoutingModelVisitor_kLightElement
5952RoutingModelVisitor.kLightElement2 = _pywrapcp.cvar.RoutingModelVisitor_kLightElement2
5953RoutingModelVisitor.kRemoveValues = _pywrapcp.cvar.RoutingModelVisitor_kRemoveValues
5954
5955class GlobalVehicleBreaksConstraint(Constraint):
5956    r"""
5957    GlobalVehicleBreaksConstraint ensures breaks constraints are enforced on
5958    all vehicles in the dimension passed to its constructor.
5959    It is intended to be used for dimensions representing time.
5960    A break constraint ensures break intervals fit on the route of a vehicle.
5961    For a given vehicle, it forces break intervals to be disjoint from visit
5962    intervals, where visit intervals start at CumulVar(node) and last for
5963    node_visit_transit[node]. Moreover, it ensures that there is enough time
5964    between two consecutive nodes of a route to do transit and vehicle breaks,
5965    i.e. if Next(nodeA) = nodeB, CumulVar(nodeA) = tA and CumulVar(nodeB) = tB,
5966    then SlackVar(nodeA) >= sum_{breaks [tA, tB)} duration(break).
5967    """
5968
5969    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5970    __repr__ = _swig_repr
5971
5972    def __init__(self, dimension):
5973        _pywrapcp.GlobalVehicleBreaksConstraint_swiginit(self, _pywrapcp.new_GlobalVehicleBreaksConstraint(dimension))
5974
5975    def DebugString(self):
5976        return _pywrapcp.GlobalVehicleBreaksConstraint_DebugString(self)
5977
5978    def Post(self):
5979        return _pywrapcp.GlobalVehicleBreaksConstraint_Post(self)
5980
5981    def InitialPropagateWrapper(self):
5982        return _pywrapcp.GlobalVehicleBreaksConstraint_InitialPropagateWrapper(self)
5983    __swig_destroy__ = _pywrapcp.delete_GlobalVehicleBreaksConstraint
5984
5985# Register GlobalVehicleBreaksConstraint in _pywrapcp:
5986_pywrapcp.GlobalVehicleBreaksConstraint_swigregister(GlobalVehicleBreaksConstraint)
5987class TypeRegulationsChecker(object):
5988    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5989
5990    def __init__(self, *args, **kwargs):
5991        raise AttributeError("No constructor defined - class is abstract")
5992    __repr__ = _swig_repr
5993    __swig_destroy__ = _pywrapcp.delete_TypeRegulationsChecker
5994
5995    def CheckVehicle(self, vehicle, next_accessor):
5996        return _pywrapcp.TypeRegulationsChecker_CheckVehicle(self, vehicle, next_accessor)
5997
5998# Register TypeRegulationsChecker in _pywrapcp:
5999_pywrapcp.TypeRegulationsChecker_swigregister(TypeRegulationsChecker)
6000class TypeIncompatibilityChecker(TypeRegulationsChecker):
6001    r""" Checker for type incompatibilities."""
6002
6003    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6004    __repr__ = _swig_repr
6005
6006    def __init__(self, model, check_hard_incompatibilities):
6007        _pywrapcp.TypeIncompatibilityChecker_swiginit(self, _pywrapcp.new_TypeIncompatibilityChecker(model, check_hard_incompatibilities))
6008    __swig_destroy__ = _pywrapcp.delete_TypeIncompatibilityChecker
6009
6010# Register TypeIncompatibilityChecker in _pywrapcp:
6011_pywrapcp.TypeIncompatibilityChecker_swigregister(TypeIncompatibilityChecker)
6012class TypeRequirementChecker(TypeRegulationsChecker):
6013    r""" Checker for type requirements."""
6014
6015    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6016    __repr__ = _swig_repr
6017
6018    def __init__(self, model):
6019        _pywrapcp.TypeRequirementChecker_swiginit(self, _pywrapcp.new_TypeRequirementChecker(model))
6020    __swig_destroy__ = _pywrapcp.delete_TypeRequirementChecker
6021
6022# Register TypeRequirementChecker in _pywrapcp:
6023_pywrapcp.TypeRequirementChecker_swigregister(TypeRequirementChecker)
6024class TypeRegulationsConstraint(Constraint):
6025    r"""
6026    The following constraint ensures that incompatibilities and requirements
6027    between types are respected.
6028
6029    It verifies both "hard" and "temporal" incompatibilities.
6030    Two nodes with hard incompatible types cannot be served by the same vehicle
6031    at all, while with a temporal incompatibility they can't be on the same
6032    route at the same time.
6033    The VisitTypePolicy of a node determines how visiting it impacts the type
6034    count on the route.
6035
6036    For example, for
6037    - three temporally incompatible types T1 T2 and T3
6038    - 2 pairs of nodes a1/r1 and a2/r2 of type T1 and T2 respectively, with
6039        - a1 and a2 of VisitTypePolicy TYPE_ADDED_TO_VEHICLE
6040        - r1 and r2 of policy ADDED_TYPE_REMOVED_FROM_VEHICLE
6041    - 3 nodes A, UV and AR of type T3, respectively with type policies
6042      TYPE_ADDED_TO_VEHICLE, TYPE_ON_VEHICLE_UP_TO_VISIT and
6043      TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED
6044    the configurations
6045    UV --> a1 --> r1 --> a2 --> r2,   a1 --> r1 --> a2 --> r2 --> A and
6046    a1 --> r1 --> AR --> a2 --> r2 are acceptable, whereas the configurations
6047    a1 --> a2 --> r1 --> ..., or A --> a1 --> r1 --> ..., or
6048    a1 --> r1 --> UV --> ... are not feasible.
6049
6050    It also verifies same-vehicle and temporal type requirements.
6051    A node of type T_d with a same-vehicle requirement for type T_r needs to be
6052    served by the same vehicle as a node of type T_r.
6053    Temporal requirements, on the other hand, can take effect either when the
6054    dependent type is being added to the route or when it's removed from it,
6055    which is determined by the dependent node's VisitTypePolicy.
6056    In the above example:
6057    - If T3 is required on the same vehicle as T1, A, AR or UV must be on the
6058      same vehicle as a1.
6059    - If T2 is required when adding T1, a2 must be visited *before* a1, and if
6060      r2 is also visited on the route, it must be *after* a1, i.e. T2 must be on
6061      the vehicle when a1 is visited:
6062      ... --> a2 --> ... --> a1 --> ... --> r2 --> ...
6063    - If T3 is required when removing T1, T3 needs to be on the vehicle when
6064      r1 is visited:
6065      ... --> A --> ... --> r1 --> ...   OR   ... --> r1 --> ... --> UV --> ...
6066    """
6067
6068    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6069    __repr__ = _swig_repr
6070
6071    def __init__(self, model):
6072        _pywrapcp.TypeRegulationsConstraint_swiginit(self, _pywrapcp.new_TypeRegulationsConstraint(model))
6073
6074    def Post(self):
6075        return _pywrapcp.TypeRegulationsConstraint_Post(self)
6076
6077    def InitialPropagateWrapper(self):
6078        return _pywrapcp.TypeRegulationsConstraint_InitialPropagateWrapper(self)
6079    __swig_destroy__ = _pywrapcp.delete_TypeRegulationsConstraint
6080
6081# Register TypeRegulationsConstraint in _pywrapcp:
6082_pywrapcp.TypeRegulationsConstraint_swigregister(TypeRegulationsConstraint)
6083class BoundCost(object):
6084    r"""
6085    A structure meant to store soft bounds and associated violation constants.
6086    It is 'Simple' because it has one BoundCost per element,
6087    in contrast to 'Multiple'. Design notes:
6088    - it is meant to store model information to be shared through pointers,
6089      so it disallows copy and assign to avoid accidental duplication.
6090    - it keeps soft bounds as an array of structs to help cache,
6091      because code that uses such bounds typically use both bound and cost.
6092    - soft bounds are named pairs, prevents some mistakes.
6093    - using operator[] to access elements is not interesting,
6094      because the structure will be accessed through pointers, moreover having
6095      to type bound_cost reminds the user of the order if they do a copy
6096      assignment of the element.
6097    """
6098
6099    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6100    __repr__ = _swig_repr
6101    bound = property(_pywrapcp.BoundCost_bound_get, _pywrapcp.BoundCost_bound_set)
6102    cost = property(_pywrapcp.BoundCost_cost_get, _pywrapcp.BoundCost_cost_set)
6103
6104    def __init__(self, *args):
6105        _pywrapcp.BoundCost_swiginit(self, _pywrapcp.new_BoundCost(*args))
6106    __swig_destroy__ = _pywrapcp.delete_BoundCost
6107
6108# Register BoundCost in _pywrapcp:
6109_pywrapcp.BoundCost_swigregister(BoundCost)
6110class SimpleBoundCosts(object):
6111    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6112    __repr__ = _swig_repr
6113
6114    def __init__(self, num_bounds, default_bound_cost):
6115        _pywrapcp.SimpleBoundCosts_swiginit(self, _pywrapcp.new_SimpleBoundCosts(num_bounds, default_bound_cost))
6116
6117    def bound_cost(self, element):
6118        return _pywrapcp.SimpleBoundCosts_bound_cost(self, element)
6119
6120    def size(self):
6121        return _pywrapcp.SimpleBoundCosts_size(self)
6122    __swig_destroy__ = _pywrapcp.delete_SimpleBoundCosts
6123
6124# Register SimpleBoundCosts in _pywrapcp:
6125_pywrapcp.SimpleBoundCosts_swigregister(SimpleBoundCosts)
6126class RoutingDimension(object):
6127    r"""
6128    Dimensions represent quantities accumulated at nodes along the routes. They
6129    represent quantities such as weights or volumes carried along the route, or
6130    distance or times.
6131
6132    Quantities at a node are represented by "cumul" variables and the increase
6133    or decrease of quantities between nodes are represented by "transit"
6134    variables. These variables are linked as follows:
6135
6136    if j == next(i),
6137    cumuls(j) = cumuls(i) + transits(i) + slacks(i) +
6138                state_dependent_transits(i)
6139
6140    where slack is a positive slack variable (can represent waiting times for
6141    a time dimension), and state_dependent_transits is a non-purely functional
6142    version of transits_. Favour transits over state_dependent_transits when
6143    possible, because purely functional callbacks allow more optimisations and
6144    make the model faster and easier to solve.
6145    for a given vehicle, it is passed as an external vector, it would be better
6146    to have this information here.
6147    """
6148
6149    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6150
6151    def __init__(self, *args, **kwargs):
6152        raise AttributeError("No constructor defined")
6153    __repr__ = _swig_repr
6154    __swig_destroy__ = _pywrapcp.delete_RoutingDimension
6155
6156    def model(self):
6157        r""" Returns the model on which the dimension was created."""
6158        return _pywrapcp.RoutingDimension_model(self)
6159
6160    def GetTransitValue(self, from_index, to_index, vehicle):
6161        r"""
6162        Returns the transition value for a given pair of nodes (as var index);
6163        this value is the one taken by the corresponding transit variable when
6164        the 'next' variable for 'from_index' is bound to 'to_index'.
6165        """
6166        return _pywrapcp.RoutingDimension_GetTransitValue(self, from_index, to_index, vehicle)
6167
6168    def GetTransitValueFromClass(self, from_index, to_index, vehicle_class):
6169        r"""
6170        Same as above but taking a vehicle class of the dimension instead of a
6171        vehicle (the class of a vehicle can be obtained with vehicle_to_class()).
6172        """
6173        return _pywrapcp.RoutingDimension_GetTransitValueFromClass(self, from_index, to_index, vehicle_class)
6174
6175    def CumulVar(self, index):
6176        r"""
6177        Get the cumul, transit and slack variables for the given node (given as
6178        int64_t var index).
6179        """
6180        return _pywrapcp.RoutingDimension_CumulVar(self, index)
6181
6182    def TransitVar(self, index):
6183        return _pywrapcp.RoutingDimension_TransitVar(self, index)
6184
6185    def FixedTransitVar(self, index):
6186        return _pywrapcp.RoutingDimension_FixedTransitVar(self, index)
6187
6188    def SlackVar(self, index):
6189        return _pywrapcp.RoutingDimension_SlackVar(self, index)
6190
6191    def SetSpanUpperBoundForVehicle(self, upper_bound, vehicle):
6192        r"""
6193        Sets an upper bound on the dimension span on a given vehicle. This is the
6194        preferred way to limit the "length" of the route of a vehicle according to
6195        a dimension.
6196        """
6197        return _pywrapcp.RoutingDimension_SetSpanUpperBoundForVehicle(self, upper_bound, vehicle)
6198
6199    def SetSpanCostCoefficientForVehicle(self, coefficient, vehicle):
6200        r"""
6201        Sets a cost proportional to the dimension span on a given vehicle,
6202        or on all vehicles at once. "coefficient" must be nonnegative.
6203        This is handy to model costs proportional to idle time when the dimension
6204        represents time.
6205        The cost for a vehicle is
6206          span_cost = coefficient * (dimension end value - dimension start value).
6207        """
6208        return _pywrapcp.RoutingDimension_SetSpanCostCoefficientForVehicle(self, coefficient, vehicle)
6209
6210    def SetSpanCostCoefficientForAllVehicles(self, coefficient):
6211        return _pywrapcp.RoutingDimension_SetSpanCostCoefficientForAllVehicles(self, coefficient)
6212
6213    def SetGlobalSpanCostCoefficient(self, coefficient):
6214        r"""
6215        Sets a cost proportional to the *global* dimension span, that is the
6216        difference between the largest value of route end cumul variables and
6217        the smallest value of route start cumul variables.
6218        In other words:
6219        global_span_cost =
6220          coefficient * (Max(dimension end value) - Min(dimension start value)).
6221        """
6222        return _pywrapcp.RoutingDimension_SetGlobalSpanCostCoefficient(self, coefficient)
6223
6224    def SetCumulVarSoftUpperBound(self, index, upper_bound, coefficient):
6225        r"""
6226        Sets a soft upper bound to the cumul variable of a given variable index.
6227        If the value of the cumul variable is greater than the bound, a cost
6228        proportional to the difference between this value and the bound is added
6229        to the cost function of the model:
6230          cumulVar <= upper_bound -> cost = 0
6231           cumulVar > upper_bound -> cost = coefficient * (cumulVar - upper_bound)
6232        This is also handy to model tardiness costs when the dimension represents
6233        time.
6234        """
6235        return _pywrapcp.RoutingDimension_SetCumulVarSoftUpperBound(self, index, upper_bound, coefficient)
6236
6237    def HasCumulVarSoftUpperBound(self, index):
6238        r"""
6239        Returns true if a soft upper bound has been set for a given variable
6240        index.
6241        """
6242        return _pywrapcp.RoutingDimension_HasCumulVarSoftUpperBound(self, index)
6243
6244    def GetCumulVarSoftUpperBound(self, index):
6245        r"""
6246        Returns the soft upper bound of a cumul variable for a given variable
6247        index. The "hard" upper bound of the variable is returned if no soft upper
6248        bound has been set.
6249        """
6250        return _pywrapcp.RoutingDimension_GetCumulVarSoftUpperBound(self, index)
6251
6252    def GetCumulVarSoftUpperBoundCoefficient(self, index):
6253        r"""
6254        Returns the cost coefficient of the soft upper bound of a cumul variable
6255        for a given variable index. If no soft upper bound has been set, 0 is
6256        returned.
6257        """
6258        return _pywrapcp.RoutingDimension_GetCumulVarSoftUpperBoundCoefficient(self, index)
6259
6260    def SetCumulVarSoftLowerBound(self, index, lower_bound, coefficient):
6261        r"""
6262        Sets a soft lower bound to the cumul variable of a given variable index.
6263        If the value of the cumul variable is less than the bound, a cost
6264        proportional to the difference between this value and the bound is added
6265        to the cost function of the model:
6266          cumulVar > lower_bound -> cost = 0
6267          cumulVar <= lower_bound -> cost = coefficient * (lower_bound -
6268                      cumulVar).
6269        This is also handy to model earliness costs when the dimension represents
6270        time.
6271        """
6272        return _pywrapcp.RoutingDimension_SetCumulVarSoftLowerBound(self, index, lower_bound, coefficient)
6273
6274    def HasCumulVarSoftLowerBound(self, index):
6275        r"""
6276        Returns true if a soft lower bound has been set for a given variable
6277        index.
6278        """
6279        return _pywrapcp.RoutingDimension_HasCumulVarSoftLowerBound(self, index)
6280
6281    def GetCumulVarSoftLowerBound(self, index):
6282        r"""
6283        Returns the soft lower bound of a cumul variable for a given variable
6284        index. The "hard" lower bound of the variable is returned if no soft lower
6285        bound has been set.
6286        """
6287        return _pywrapcp.RoutingDimension_GetCumulVarSoftLowerBound(self, index)
6288
6289    def GetCumulVarSoftLowerBoundCoefficient(self, index):
6290        r"""
6291        Returns the cost coefficient of the soft lower bound of a cumul variable
6292        for a given variable index. If no soft lower bound has been set, 0 is
6293        returned.
6294        """
6295        return _pywrapcp.RoutingDimension_GetCumulVarSoftLowerBoundCoefficient(self, index)
6296
6297    def SetBreakIntervalsOfVehicle(self, breaks, vehicle, node_visit_transits):
6298        r"""
6299        Sets the breaks for a given vehicle. Breaks are represented by
6300        IntervalVars. They may interrupt transits between nodes and increase
6301        the value of corresponding slack variables.
6302        A break may take place before the start of a vehicle, after the end of
6303        a vehicle, or during a travel i -> j.
6304
6305        In that case, the interval [break.Start(), break.End()) must be a subset
6306        of [CumulVar(i) + pre_travel(i, j), CumulVar(j) - post_travel(i, j)). In
6307        other words, a break may not overlap any node n's visit, given by
6308        [CumulVar(n) - post_travel(_, n), CumulVar(n) + pre_travel(n, _)).
6309        This formula considers post_travel(_, start) and pre_travel(end, _) to be
6310        0; pre_travel will never be called on any (_, start) and post_travel will
6311        never we called on any (end, _). If pre_travel_evaluator or
6312        post_travel_evaluator is -1, it will be taken as a function that always
6313        returns 0.
6314        Deprecated, sets pre_travel(i, j) = node_visit_transit[i].
6315        """
6316        return _pywrapcp.RoutingDimension_SetBreakIntervalsOfVehicle(self, breaks, vehicle, node_visit_transits)
6317
6318    def SetBreakDistanceDurationOfVehicle(self, distance, duration, vehicle):
6319        r"""
6320        With breaks supposed to be consecutive, this forces the distance between
6321        breaks of size at least minimum_break_duration to be at most distance.
6322        This supposes that the time until route start and after route end are
6323        infinite breaks.
6324        """
6325        return _pywrapcp.RoutingDimension_SetBreakDistanceDurationOfVehicle(self, distance, duration, vehicle)
6326
6327    def InitializeBreaks(self):
6328        r"""
6329        Sets up vehicle_break_intervals_, vehicle_break_distance_duration_,
6330        pre_travel_evaluators and post_travel_evaluators.
6331        """
6332        return _pywrapcp.RoutingDimension_InitializeBreaks(self)
6333
6334    def HasBreakConstraints(self):
6335        r""" Returns true if any break interval or break distance was defined."""
6336        return _pywrapcp.RoutingDimension_HasBreakConstraints(self)
6337
6338    def GetPreTravelEvaluatorOfVehicle(self, vehicle):
6339        return _pywrapcp.RoutingDimension_GetPreTravelEvaluatorOfVehicle(self, vehicle)
6340
6341    def GetPostTravelEvaluatorOfVehicle(self, vehicle):
6342        return _pywrapcp.RoutingDimension_GetPostTravelEvaluatorOfVehicle(self, vehicle)
6343
6344    def base_dimension(self):
6345        r""" Returns the parent in the dependency tree if any or nullptr otherwise."""
6346        return _pywrapcp.RoutingDimension_base_dimension(self)
6347
6348    def ShortestTransitionSlack(self, node):
6349        r"""
6350        It makes sense to use the function only for self-dependent dimension.
6351        For such dimensions the value of the slack of a node determines the
6352        transition cost of the next transit. Provided that
6353          1. cumul[node] is fixed,
6354          2. next[node] and next[next[node]] (if exists) are fixed,
6355        the value of slack[node] for which cumul[next[node]] + transit[next[node]]
6356        is minimized can be found in O(1) using this function.
6357        """
6358        return _pywrapcp.RoutingDimension_ShortestTransitionSlack(self, node)
6359
6360    def name(self):
6361        r""" Returns the name of the dimension."""
6362        return _pywrapcp.RoutingDimension_name(self)
6363
6364    def SetPickupToDeliveryLimitFunctionForPair(self, limit_function, pair_index):
6365        return _pywrapcp.RoutingDimension_SetPickupToDeliveryLimitFunctionForPair(self, limit_function, pair_index)
6366
6367    def HasPickupToDeliveryLimits(self):
6368        return _pywrapcp.RoutingDimension_HasPickupToDeliveryLimits(self)
6369
6370    def AddNodePrecedence(self, first_node, second_node, offset):
6371        return _pywrapcp.RoutingDimension_AddNodePrecedence(self, first_node, second_node, offset)
6372
6373    def GetSpanUpperBoundForVehicle(self, vehicle):
6374        return _pywrapcp.RoutingDimension_GetSpanUpperBoundForVehicle(self, vehicle)
6375
6376    def GetSpanCostCoefficientForVehicle(self, vehicle):
6377        return _pywrapcp.RoutingDimension_GetSpanCostCoefficientForVehicle(self, vehicle)
6378
6379    def global_span_cost_coefficient(self):
6380        return _pywrapcp.RoutingDimension_global_span_cost_coefficient(self)
6381
6382    def GetGlobalOptimizerOffset(self):
6383        return _pywrapcp.RoutingDimension_GetGlobalOptimizerOffset(self)
6384
6385    def GetLocalOptimizerOffsetForVehicle(self, vehicle):
6386        return _pywrapcp.RoutingDimension_GetLocalOptimizerOffsetForVehicle(self, vehicle)
6387
6388    def SetSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle):
6389        r"""
6390        If the span of vehicle on this dimension is larger than bound,
6391        the cost will be increased by cost * (span - bound).
6392        """
6393        return _pywrapcp.RoutingDimension_SetSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle)
6394
6395    def HasSoftSpanUpperBounds(self):
6396        return _pywrapcp.RoutingDimension_HasSoftSpanUpperBounds(self)
6397
6398    def GetSoftSpanUpperBoundForVehicle(self, vehicle):
6399        return _pywrapcp.RoutingDimension_GetSoftSpanUpperBoundForVehicle(self, vehicle)
6400
6401    def SetQuadraticCostSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle):
6402        r"""
6403        If the span of vehicle on this dimension is larger than bound,
6404        the cost will be increased by cost * (span - bound)^2.
6405        """
6406        return _pywrapcp.RoutingDimension_SetQuadraticCostSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle)
6407
6408    def HasQuadraticCostSoftSpanUpperBounds(self):
6409        return _pywrapcp.RoutingDimension_HasQuadraticCostSoftSpanUpperBounds(self)
6410
6411    def GetQuadraticCostSoftSpanUpperBoundForVehicle(self, vehicle):
6412        return _pywrapcp.RoutingDimension_GetQuadraticCostSoftSpanUpperBoundForVehicle(self, vehicle)
6413
6414# Register RoutingDimension in _pywrapcp:
6415_pywrapcp.RoutingDimension_swigregister(RoutingDimension)
6416
6417def SolveModelWithSat(model, search_parameters, initial_solution, solution):
6418    r"""
6419    Attempts to solve the model using the cp-sat solver. As of 5/2019, will
6420    solve the TSP corresponding to the model if it has a single vehicle.
6421    Therefore the resulting solution might not actually be feasible. Will return
6422    false if a solution could not be found.
6423    """
6424    return _pywrapcp.SolveModelWithSat(model, search_parameters, initial_solution, solution)
class DefaultPhaseParameters:
 64class DefaultPhaseParameters(object):
 65    r"""
 66    This struct holds all parameters for the default search.
 67    DefaultPhaseParameters is only used by Solver::MakeDefaultPhase methods.
 68    Note this is for advanced users only.
 69    """
 70
 71    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
 72    __repr__ = _swig_repr
 73    CHOOSE_MAX_SUM_IMPACT = _pywrapcp.DefaultPhaseParameters_CHOOSE_MAX_SUM_IMPACT
 74    CHOOSE_MAX_AVERAGE_IMPACT = _pywrapcp.DefaultPhaseParameters_CHOOSE_MAX_AVERAGE_IMPACT
 75    CHOOSE_MAX_VALUE_IMPACT = _pywrapcp.DefaultPhaseParameters_CHOOSE_MAX_VALUE_IMPACT
 76    SELECT_MIN_IMPACT = _pywrapcp.DefaultPhaseParameters_SELECT_MIN_IMPACT
 77    SELECT_MAX_IMPACT = _pywrapcp.DefaultPhaseParameters_SELECT_MAX_IMPACT
 78    NONE = _pywrapcp.DefaultPhaseParameters_NONE
 79    NORMAL = _pywrapcp.DefaultPhaseParameters_NORMAL
 80    VERBOSE = _pywrapcp.DefaultPhaseParameters_VERBOSE
 81    var_selection_schema = property(_pywrapcp.DefaultPhaseParameters_var_selection_schema_get, _pywrapcp.DefaultPhaseParameters_var_selection_schema_set, doc=r"""
 82    This parameter describes how the next variable to instantiate
 83    will be chosen.
 84    """)
 85    value_selection_schema = property(_pywrapcp.DefaultPhaseParameters_value_selection_schema_get, _pywrapcp.DefaultPhaseParameters_value_selection_schema_set, doc=r""" This parameter describes which value to select for a given var.""")
 86    initialization_splits = property(_pywrapcp.DefaultPhaseParameters_initialization_splits_get, _pywrapcp.DefaultPhaseParameters_initialization_splits_set, doc=r"""
 87    Maximum number of intervals that the initialization of impacts will scan
 88    per variable.
 89    """)
 90    run_all_heuristics = property(_pywrapcp.DefaultPhaseParameters_run_all_heuristics_get, _pywrapcp.DefaultPhaseParameters_run_all_heuristics_set, doc=r"""
 91    The default phase will run heuristics periodically. This parameter
 92    indicates if we should run all heuristics, or a randomly selected
 93    one.
 94    """)
 95    heuristic_period = property(_pywrapcp.DefaultPhaseParameters_heuristic_period_get, _pywrapcp.DefaultPhaseParameters_heuristic_period_set, doc=r"""
 96    The distance in nodes between each run of the heuristics. A
 97    negative or null value will mean that we will not run heuristics
 98    at all.
 99    """)
100    heuristic_num_failures_limit = property(_pywrapcp.DefaultPhaseParameters_heuristic_num_failures_limit_get, _pywrapcp.DefaultPhaseParameters_heuristic_num_failures_limit_set, doc=r""" The failure limit for each heuristic that we run.""")
101    persistent_impact = property(_pywrapcp.DefaultPhaseParameters_persistent_impact_get, _pywrapcp.DefaultPhaseParameters_persistent_impact_set, doc=r"""
102    Whether to keep the impact from the first search for other searches,
103    or to recompute the impact for each new search.
104    """)
105    random_seed = property(_pywrapcp.DefaultPhaseParameters_random_seed_get, _pywrapcp.DefaultPhaseParameters_random_seed_set, doc=r""" Seed used to initialize the random part in some heuristics.""")
106    display_level = property(_pywrapcp.DefaultPhaseParameters_display_level_get, _pywrapcp.DefaultPhaseParameters_display_level_set, doc=r"""
107    This represents the amount of information displayed by the default search.
108    NONE means no display, VERBOSE means extra information.
109    """)
110    decision_builder = property(_pywrapcp.DefaultPhaseParameters_decision_builder_get, _pywrapcp.DefaultPhaseParameters_decision_builder_set, doc=r""" When defined, this overrides the default impact based decision builder.""")
111
112    def __init__(self):
113        _pywrapcp.DefaultPhaseParameters_swiginit(self, _pywrapcp.new_DefaultPhaseParameters())
114    __swig_destroy__ = _pywrapcp.delete_DefaultPhaseParameters

This struct holds all parameters for the default search. DefaultPhaseParameters is only used by Solver::MakeDefaultPhase methods. Note this is for advanced users only.

thisown

The membership flag

CHOOSE_MAX_SUM_IMPACT = 0
CHOOSE_MAX_AVERAGE_IMPACT = 1
CHOOSE_MAX_VALUE_IMPACT = 2
SELECT_MIN_IMPACT = 0
SELECT_MAX_IMPACT = 1
NONE = 0
NORMAL = 1
VERBOSE = 2
var_selection_schema

This parameter describes how the next variable to instantiate will be chosen.

value_selection_schema

This parameter describes which value to select for a given var.

initialization_splits

Maximum number of intervals that the initialization of impacts will scan per variable.

run_all_heuristics

The default phase will run heuristics periodically. This parameter indicates if we should run all heuristics, or a randomly selected one.

heuristic_period

The distance in nodes between each run of the heuristics. A negative or null value will mean that we will not run heuristics at all.

heuristic_num_failures_limit

The failure limit for each heuristic that we run.

persistent_impact

Whether to keep the impact from the first search for other searches, or to recompute the impact for each new search.

random_seed

Seed used to initialize the random part in some heuristics.

display_level

This represents the amount of information displayed by the default search. NONE means no display, VERBOSE means extra information.

decision_builder

When defined, this overrides the default impact based decision builder.

class Solver:
 118class Solver(object):
 119    r"""
 120    Solver Class
 121
 122    A solver represents the main computation engine. It implements the entire
 123    range of Constraint Programming protocols:
 124      - Reversibility
 125      - Propagation
 126      - Search
 127
 128    Usually, Constraint Programming code consists of
 129      - the creation of the Solver,
 130      - the creation of the decision variables of the model,
 131      - the creation of the constraints of the model and their addition to the
 132        solver() through the AddConstraint() method,
 133      - the creation of the main DecisionBuilder class,
 134      - the launch of the solve() method with the decision builder.
 135
 136    For the time being, Solver is neither MT_SAFE nor MT_HOT.
 137    """
 138
 139    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
 140    __repr__ = _swig_repr
 141    INT_VAR_DEFAULT = _pywrapcp.Solver_INT_VAR_DEFAULT
 142    r""" The default behavior is CHOOSE_FIRST_UNBOUND."""
 143    INT_VAR_SIMPLE = _pywrapcp.Solver_INT_VAR_SIMPLE
 144    r""" The simple selection is CHOOSE_FIRST_UNBOUND."""
 145    CHOOSE_FIRST_UNBOUND = _pywrapcp.Solver_CHOOSE_FIRST_UNBOUND
 146    r"""
 147    Select the first unbound variable.
 148    Variables are considered in the order of the vector of IntVars used
 149    to create the selector.
 150    """
 151    CHOOSE_RANDOM = _pywrapcp.Solver_CHOOSE_RANDOM
 152    r""" Randomly select one of the remaining unbound variables."""
 153    CHOOSE_MIN_SIZE_LOWEST_MIN = _pywrapcp.Solver_CHOOSE_MIN_SIZE_LOWEST_MIN
 154    r"""
 155    Among unbound variables, select the variable with the smallest size,
 156    i.e., the smallest number of possible values.
 157    In case of a tie, the selected variables is the one with the lowest min
 158    value.
 159    In case of a tie, the first one is selected, first being defined by the
 160    order in the vector of IntVars used to create the selector.
 161    """
 162    CHOOSE_MIN_SIZE_HIGHEST_MIN = _pywrapcp.Solver_CHOOSE_MIN_SIZE_HIGHEST_MIN
 163    r"""
 164    Among unbound variables, select the variable with the smallest size,
 165    i.e., the smallest number of possible values.
 166    In case of a tie, the selected variable is the one with the highest min
 167    value.
 168    In case of a tie, the first one is selected, first being defined by the
 169    order in the vector of IntVars used to create the selector.
 170    """
 171    CHOOSE_MIN_SIZE_LOWEST_MAX = _pywrapcp.Solver_CHOOSE_MIN_SIZE_LOWEST_MAX
 172    r"""
 173    Among unbound variables, select the variable with the smallest size,
 174    i.e., the smallest number of possible values.
 175    In case of a tie, the selected variables is the one with the lowest max
 176    value.
 177    In case of a tie, the first one is selected, first being defined by the
 178    order in the vector of IntVars used to create the selector.
 179    """
 180    CHOOSE_MIN_SIZE_HIGHEST_MAX = _pywrapcp.Solver_CHOOSE_MIN_SIZE_HIGHEST_MAX
 181    r"""
 182    Among unbound variables, select the variable with the smallest size,
 183    i.e., the smallest number of possible values.
 184    In case of a tie, the selected variable is the one with the highest max
 185    value.
 186    In case of a tie, the first one is selected, first being defined by the
 187    order in the vector of IntVars used to create the selector.
 188    """
 189    CHOOSE_LOWEST_MIN = _pywrapcp.Solver_CHOOSE_LOWEST_MIN
 190    r"""
 191    Among unbound variables, select the variable with the smallest minimal
 192    value.
 193    In case of a tie, the first one is selected, "first" defined by the
 194    order in the vector of IntVars used to create the selector.
 195    """
 196    CHOOSE_HIGHEST_MAX = _pywrapcp.Solver_CHOOSE_HIGHEST_MAX
 197    r"""
 198    Among unbound variables, select the variable with the highest maximal
 199    value.
 200    In case of a tie, the first one is selected, first being defined by the
 201    order in the vector of IntVars used to create the selector.
 202    """
 203    CHOOSE_MIN_SIZE = _pywrapcp.Solver_CHOOSE_MIN_SIZE
 204    r"""
 205    Among unbound variables, select the variable with the smallest size.
 206    In case of a tie, the first one is selected, first being defined by the
 207    order in the vector of IntVars used to create the selector.
 208    """
 209    CHOOSE_MAX_SIZE = _pywrapcp.Solver_CHOOSE_MAX_SIZE
 210    r"""
 211    Among unbound variables, select the variable with the highest size.
 212    In case of a tie, the first one is selected, first being defined by the
 213    order in the vector of IntVars used to create the selector.
 214    """
 215    CHOOSE_MAX_REGRET_ON_MIN = _pywrapcp.Solver_CHOOSE_MAX_REGRET_ON_MIN
 216    r"""
 217    Among unbound variables, select the variable with the largest
 218    gap between the first and the second values of the domain.
 219    """
 220    CHOOSE_PATH = _pywrapcp.Solver_CHOOSE_PATH
 221    r"""
 222    Selects the next unbound variable on a path, the path being defined by
 223    the variables: var[i] corresponds to the index of the next of i.
 224    """
 225    INT_VALUE_DEFAULT = _pywrapcp.Solver_INT_VALUE_DEFAULT
 226    r""" The default behavior is ASSIGN_MIN_VALUE."""
 227    INT_VALUE_SIMPLE = _pywrapcp.Solver_INT_VALUE_SIMPLE
 228    r""" The simple selection is ASSIGN_MIN_VALUE."""
 229    ASSIGN_MIN_VALUE = _pywrapcp.Solver_ASSIGN_MIN_VALUE
 230    r""" Selects the min value of the selected variable."""
 231    ASSIGN_MAX_VALUE = _pywrapcp.Solver_ASSIGN_MAX_VALUE
 232    r""" Selects the max value of the selected variable."""
 233    ASSIGN_RANDOM_VALUE = _pywrapcp.Solver_ASSIGN_RANDOM_VALUE
 234    r""" Selects randomly one of the possible values of the selected variable."""
 235    ASSIGN_CENTER_VALUE = _pywrapcp.Solver_ASSIGN_CENTER_VALUE
 236    r"""
 237    Selects the first possible value which is the closest to the center
 238    of the domain of the selected variable.
 239    The center is defined as (min + max) / 2.
 240    """
 241    SPLIT_LOWER_HALF = _pywrapcp.Solver_SPLIT_LOWER_HALF
 242    r"""
 243    Split the domain in two around the center, and choose the lower
 244    part first.
 245    """
 246    SPLIT_UPPER_HALF = _pywrapcp.Solver_SPLIT_UPPER_HALF
 247    r"""
 248    Split the domain in two around the center, and choose the lower
 249    part first.
 250    """
 251    SEQUENCE_DEFAULT = _pywrapcp.Solver_SEQUENCE_DEFAULT
 252    SEQUENCE_SIMPLE = _pywrapcp.Solver_SEQUENCE_SIMPLE
 253    CHOOSE_MIN_SLACK_RANK_FORWARD = _pywrapcp.Solver_CHOOSE_MIN_SLACK_RANK_FORWARD
 254    CHOOSE_RANDOM_RANK_FORWARD = _pywrapcp.Solver_CHOOSE_RANDOM_RANK_FORWARD
 255    INTERVAL_DEFAULT = _pywrapcp.Solver_INTERVAL_DEFAULT
 256    r""" The default is INTERVAL_SET_TIMES_FORWARD."""
 257    INTERVAL_SIMPLE = _pywrapcp.Solver_INTERVAL_SIMPLE
 258    r""" The simple is INTERVAL_SET_TIMES_FORWARD."""
 259    INTERVAL_SET_TIMES_FORWARD = _pywrapcp.Solver_INTERVAL_SET_TIMES_FORWARD
 260    r"""
 261    Selects the variable with the lowest starting time of all variables,
 262    and fixes its starting time to this lowest value.
 263    """
 264    INTERVAL_SET_TIMES_BACKWARD = _pywrapcp.Solver_INTERVAL_SET_TIMES_BACKWARD
 265    r"""
 266    Selects the variable with the highest ending time of all variables,
 267    and fixes the ending time to this highest values.
 268    """
 269    TWOOPT = _pywrapcp.Solver_TWOOPT
 270    r"""
 271    Operator which reverses a sub-chain of a path. It is called TwoOpt
 272    because it breaks two arcs on the path; resulting paths are called
 273    two-optimal.
 274    Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5
 275    (where (1, 5) are first and last nodes of the path and can therefore not
 276    be moved):
 277      1 -> [3 -> 2] -> 4  -> 5
 278      1 -> [4 -> 3  -> 2] -> 5
 279      1 ->  2 -> [4 -> 3] -> 5
 280    """
 281    OROPT = _pywrapcp.Solver_OROPT
 282    r"""
 283    Relocate: OROPT and RELOCATE.
 284    Operator which moves a sub-chain of a path to another position; the
 285    specified chain length is the fixed length of the chains being moved.
 286    When this length is 1, the operator simply moves a node to another
 287    position.
 288    Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5, for a chain
 289    length of 2 (where (1, 5) are first and last nodes of the path and can
 290    therefore not be moved):
 291      1 ->  4 -> [2 -> 3] -> 5
 292      1 -> [3 -> 4] -> 2  -> 5
 293
 294    Using Relocate with chain lengths of 1, 2 and 3 together is equivalent
 295    to the OrOpt operator on a path. The OrOpt operator is a limited
 296     version of 3Opt (breaks 3 arcs on a path).
 297    """
 298    RELOCATE = _pywrapcp.Solver_RELOCATE
 299    r""" Relocate neighborhood with length of 1 (see OROPT comment)."""
 300    EXCHANGE = _pywrapcp.Solver_EXCHANGE
 301    r"""
 302    Operator which exchanges the positions of two nodes.
 303    Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5
 304    (where (1, 5) are first and last nodes of the path and can therefore not
 305    be moved):
 306      1 -> [3] -> [2] ->  4  -> 5
 307      1 -> [4] ->  3  -> [2] -> 5
 308      1 ->  2  -> [4] -> [3] -> 5
 309    """
 310    CROSS = _pywrapcp.Solver_CROSS
 311    r"""
 312    Operator which cross exchanges the starting chains of 2 paths, including
 313    exchanging the whole paths.
 314    First and last nodes are not moved.
 315    Possible neighbors for the paths 1 -> 2 -> 3 -> 4 -> 5 and 6 -> 7 -> 8
 316    (where (1, 5) and (6, 8) are first and last nodes of the paths and can
 317    therefore not be moved):
 318      1 -> [7] -> 3 -> 4 -> 5  6 -> [2] -> 8
 319      1 -> [7] -> 4 -> 5       6 -> [2 -> 3] -> 8
 320      1 -> [7] -> 5            6 -> [2 -> 3 -> 4] -> 8
 321    """
 322    MAKEACTIVE = _pywrapcp.Solver_MAKEACTIVE
 323    r"""
 324    Operator which inserts an inactive node into a path.
 325    Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive
 326    (where 1 and 4 are first and last nodes of the path) are:
 327      1 -> [5] ->  2  ->  3  -> 4
 328      1 ->  2  -> [5] ->  3  -> 4
 329      1 ->  2  ->  3  -> [5] -> 4
 330    """
 331    MAKEINACTIVE = _pywrapcp.Solver_MAKEINACTIVE
 332    r"""
 333    Operator which makes path nodes inactive.
 334    Possible neighbors for the path 1 -> 2 -> 3 -> 4 (where 1 and 4 are
 335    first and last nodes of the path) are:
 336      1 -> 3 -> 4 with 2 inactive
 337      1 -> 2 -> 4 with 3 inactive
 338    """
 339    MAKECHAININACTIVE = _pywrapcp.Solver_MAKECHAININACTIVE
 340    r"""
 341    Operator which makes a "chain" of path nodes inactive.
 342    Possible neighbors for the path 1 -> 2 -> 3 -> 4 (where 1 and 4 are
 343    first and last nodes of the path) are:
 344      1 -> 3 -> 4 with 2 inactive
 345      1 -> 2 -> 4 with 3 inactive
 346      1 -> 4 with 2 and 3 inactive
 347    """
 348    SWAPACTIVE = _pywrapcp.Solver_SWAPACTIVE
 349    r"""
 350    Operator which replaces an active node by an inactive one.
 351    Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive
 352    (where 1 and 4 are first and last nodes of the path) are:
 353      1 -> [5] ->  3  -> 4 with 2 inactive
 354      1 ->  2  -> [5] -> 4 with 3 inactive
 355    """
 356    EXTENDEDSWAPACTIVE = _pywrapcp.Solver_EXTENDEDSWAPACTIVE
 357    r"""
 358    Operator which makes an inactive node active and an active one inactive.
 359    It is similar to SwapActiveOperator except that it tries to insert the
 360    inactive node in all possible positions instead of just the position of
 361    the node made inactive.
 362    Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive
 363    (where 1 and 4 are first and last nodes of the path) are:
 364      1 -> [5] ->  3  -> 4 with 2 inactive
 365      1 ->  3  -> [5] -> 4 with 2 inactive
 366      1 -> [5] ->  2  -> 4 with 3 inactive
 367      1 ->  2  -> [5] -> 4 with 3 inactive
 368    """
 369    PATHLNS = _pywrapcp.Solver_PATHLNS
 370    r"""
 371    Operator which relaxes two sub-chains of three consecutive arcs each.
 372    Each sub-chain is defined by a start node and the next three arcs. Those
 373    six arcs are relaxed to build a new neighbor.
 374    PATHLNS explores all possible pairs of starting nodes and so defines
 375    n^2 neighbors, n being the number of nodes.
 376    Note that the two sub-chains can be part of the same path; they even may
 377    overlap.
 378    """
 379    FULLPATHLNS = _pywrapcp.Solver_FULLPATHLNS
 380    r"""
 381    Operator which relaxes one entire path and all inactive nodes, thus
 382    defining num_paths neighbors.
 383    """
 384    UNACTIVELNS = _pywrapcp.Solver_UNACTIVELNS
 385    r"""
 386    Operator which relaxes all inactive nodes and one sub-chain of six
 387    consecutive arcs. That way the path can be improved by inserting
 388    inactive nodes or swapping arcs.
 389    """
 390    INCREMENT = _pywrapcp.Solver_INCREMENT
 391    r"""
 392    Operator which defines one neighbor per variable. Each neighbor tries to
 393    increment by one the value of the corresponding variable. When a new
 394    solution is found the neighborhood is rebuilt from scratch, i.e., tries
 395    to increment values in the variable order.
 396    Consider for instance variables x and y. x is incremented one by one to
 397    its max, and when it is not possible to increment x anymore, y is
 398    incremented once. If this is a solution, then next neighbor tries to
 399    increment x.
 400    """
 401    DECREMENT = _pywrapcp.Solver_DECREMENT
 402    r"""
 403    Operator which defines a neighborhood to decrement values.
 404    The behavior is the same as INCREMENT, except values are decremented
 405    instead of incremented.
 406    """
 407    SIMPLELNS = _pywrapcp.Solver_SIMPLELNS
 408    r"""
 409    Operator which defines one neighbor per variable. Each neighbor relaxes
 410    one variable.
 411    When a new solution is found the neighborhood is rebuilt from scratch.
 412    Consider for instance variables x and y. First x is relaxed and the
 413    solver is looking for the best possible solution (with only x relaxed).
 414    Then y is relaxed, and the solver is looking for a new solution.
 415    If a new solution is found, then the next variable to be relaxed is x.
 416    """
 417    GE = _pywrapcp.Solver_GE
 418    r""" Move is accepted when the current objective value >= objective.Min."""
 419    LE = _pywrapcp.Solver_LE
 420    r""" Move is accepted when the current objective value <= objective.Max."""
 421    EQ = _pywrapcp.Solver_EQ
 422    r"""
 423    Move is accepted when the current objective value is in the interval
 424    objective.Min .. objective.Max.
 425    """
 426    DELAYED_PRIORITY = _pywrapcp.Solver_DELAYED_PRIORITY
 427    r"""
 428    DELAYED_PRIORITY is the lowest priority: Demons will be processed after
 429    VAR_PRIORITY and NORMAL_PRIORITY demons.
 430    """
 431    VAR_PRIORITY = _pywrapcp.Solver_VAR_PRIORITY
 432    r""" VAR_PRIORITY is between DELAYED_PRIORITY and NORMAL_PRIORITY."""
 433    NORMAL_PRIORITY = _pywrapcp.Solver_NORMAL_PRIORITY
 434    r""" NORMAL_PRIORITY is the highest priority: Demons will be processed first."""
 435
 436    def __init__(self, *args):
 437        _pywrapcp.Solver_swiginit(self, _pywrapcp.new_Solver(*args))
 438
 439        self.__python_constraints = []
 440
 441
 442
 443    __swig_destroy__ = _pywrapcp.delete_Solver
 444
 445    def Parameters(self):
 446        r""" Stored Parameters."""
 447        return _pywrapcp.Solver_Parameters(self)
 448
 449    @staticmethod
 450    def DefaultSolverParameters():
 451        r""" Create a ConstraintSolverParameters proto with all the default values."""
 452        return _pywrapcp.Solver_DefaultSolverParameters()
 453
 454    def AddConstraint(self, c):
 455        r"""
 456        Adds the constraint 'c' to the model.
 457
 458        After calling this method, and until there is a backtrack that undoes the
 459        addition, any assignment of variables to values must satisfy the given
 460        constraint in order to be considered feasible. There are two fairly
 461        different use cases:
 462
 463        - the most common use case is modeling: the given constraint is really
 464        part of the problem that the user is trying to solve. In this use case,
 465        AddConstraint is called outside of search (i.e., with state() ==
 466        OUTSIDE_SEARCH). Most users should only use AddConstraint in this
 467        way. In this case, the constraint will belong to the model forever: it
 468        cannot be removed by backtracking.
 469
 470        - a rarer use case is that 'c' is not a real constraint of the model. It
 471        may be a constraint generated by a branching decision (a constraint whose
 472        goal is to restrict the search space), a symmetry breaking constraint (a
 473        constraint that does restrict the search space, but in a way that cannot
 474        have an impact on the quality of the solutions in the subtree), or an
 475        inferred constraint that, while having no semantic value to the model (it
 476        does not restrict the set of solutions), is worth having because we
 477        believe it may strengthen the propagation. In these cases, it happens
 478        that the constraint is added during the search (i.e., with state() ==
 479        IN_SEARCH or state() == IN_ROOT_NODE). When a constraint is
 480        added during a search, it applies only to the subtree of the search tree
 481        rooted at the current node, and will be automatically removed by
 482        backtracking.
 483
 484        This method does not take ownership of the constraint. If the constraint
 485        has been created by any factory method (Solver::MakeXXX), it will
 486        automatically be deleted. However, power users who implement their own
 487        constraints should do: solver.AddConstraint(solver.RevAlloc(new
 488        MyConstraint(...));
 489        """
 490        return _pywrapcp.Solver_AddConstraint(self, c)
 491
 492    def Solve(self, *args):
 493        return _pywrapcp.Solver_Solve(self, *args)
 494
 495    def NewSearch(self, *args):
 496        return _pywrapcp.Solver_NewSearch(self, *args)
 497
 498    def NextSolution(self):
 499        return _pywrapcp.Solver_NextSolution(self)
 500
 501    def RestartSearch(self):
 502        return _pywrapcp.Solver_RestartSearch(self)
 503
 504    def EndSearch(self):
 505        return _pywrapcp.Solver_EndSearch(self)
 506
 507    def SolveAndCommit(self, *args):
 508        return _pywrapcp.Solver_SolveAndCommit(self, *args)
 509
 510    def CheckAssignment(self, solution):
 511        r""" Checks whether the given assignment satisfies all relevant constraints."""
 512        return _pywrapcp.Solver_CheckAssignment(self, solution)
 513
 514    def CheckConstraint(self, ct):
 515        r"""
 516        Checks whether adding this constraint will lead to an immediate
 517        failure. It will return false if the model is already inconsistent, or if
 518        adding the constraint makes it inconsistent.
 519        """
 520        return _pywrapcp.Solver_CheckConstraint(self, ct)
 521
 522    def Fail(self):
 523        r""" Abandon the current branch in the search tree. A backtrack will follow."""
 524        return _pywrapcp.Solver_Fail(self)
 525
 526    @staticmethod
 527    def MemoryUsage():
 528        r""" Current memory usage in bytes"""
 529        return _pywrapcp.Solver_MemoryUsage()
 530
 531    def WallTime(self):
 532        r"""
 533        DEPRECATED: Use Now() instead.
 534        Time elapsed, in ms since the creation of the solver.
 535        """
 536        return _pywrapcp.Solver_WallTime(self)
 537
 538    def Branches(self):
 539        r""" The number of branches explored since the creation of the solver."""
 540        return _pywrapcp.Solver_Branches(self)
 541
 542    def Solutions(self):
 543        r""" The number of solutions found since the start of the search."""
 544        return _pywrapcp.Solver_Solutions(self)
 545
 546    def Failures(self):
 547        r""" The number of failures encountered since the creation of the solver."""
 548        return _pywrapcp.Solver_Failures(self)
 549
 550    def AcceptedNeighbors(self):
 551        r""" The number of accepted neighbors."""
 552        return _pywrapcp.Solver_AcceptedNeighbors(self)
 553
 554    def Stamp(self):
 555        r"""
 556        The stamp indicates how many moves in the search tree we have performed.
 557        It is useful to detect if we need to update same lazy structures.
 558        """
 559        return _pywrapcp.Solver_Stamp(self)
 560
 561    def FailStamp(self):
 562        r""" The fail_stamp() is incremented after each backtrack."""
 563        return _pywrapcp.Solver_FailStamp(self)
 564
 565    def IntVar(self, *args):
 566        r"""
 567        *Overload 1:*
 568        MakeIntVar will create the best range based int var for the bounds given.
 569
 570        |
 571
 572        *Overload 2:*
 573        MakeIntVar will create a variable with the given sparse domain.
 574
 575        |
 576
 577        *Overload 3:*
 578        MakeIntVar will create a variable with the given sparse domain.
 579
 580        |
 581
 582        *Overload 4:*
 583        MakeIntVar will create the best range based int var for the bounds given.
 584
 585        |
 586
 587        *Overload 5:*
 588        MakeIntVar will create a variable with the given sparse domain.
 589
 590        |
 591
 592        *Overload 6:*
 593        MakeIntVar will create a variable with the given sparse domain.
 594        """
 595        return _pywrapcp.Solver_IntVar(self, *args)
 596
 597    def BoolVar(self, *args):
 598        r"""
 599        *Overload 1:*
 600        MakeBoolVar will create a variable with a {0, 1} domain.
 601
 602        |
 603
 604        *Overload 2:*
 605        MakeBoolVar will create a variable with a {0, 1} domain.
 606        """
 607        return _pywrapcp.Solver_BoolVar(self, *args)
 608
 609    def IntConst(self, *args):
 610        r"""
 611        *Overload 1:*
 612        IntConst will create a constant expression.
 613
 614        |
 615
 616        *Overload 2:*
 617        IntConst will create a constant expression.
 618        """
 619        return _pywrapcp.Solver_IntConst(self, *args)
 620
 621    def Sum(self, vars):
 622        r""" sum of all vars."""
 623        return _pywrapcp.Solver_Sum(self, vars)
 624
 625    def ScalProd(self, *args):
 626        r"""
 627        *Overload 1:*
 628        scalar product
 629
 630        |
 631
 632        *Overload 2:*
 633        scalar product
 634        """
 635        return _pywrapcp.Solver_ScalProd(self, *args)
 636
 637    def MonotonicElement(self, values, increasing, index):
 638        r"""
 639        Function based element. The constraint takes ownership of the
 640        callback.  The callback must be monotonic. It must be able to
 641        cope with any possible value in the domain of 'index'
 642        (potentially negative ones too). Furtermore, monotonicity is not
 643        checked. Thus giving a non-monotonic function, or specifying an
 644        incorrect increasing parameter will result in undefined behavior.
 645        """
 646        return _pywrapcp.Solver_MonotonicElement(self, values, increasing, index)
 647
 648    def Element(self, *args):
 649        r"""
 650        *Overload 1:*
 651        values[index]
 652
 653        |
 654
 655        *Overload 2:*
 656        values[index]
 657
 658        |
 659
 660        *Overload 3:*
 661        Function-based element. The constraint takes ownership of the
 662        callback. The callback must be able to cope with any possible
 663        value in the domain of 'index' (potentially negative ones too).
 664
 665        |
 666
 667        *Overload 4:*
 668        2D version of function-based element expression, values(expr1, expr2).
 669
 670        |
 671
 672        *Overload 5:*
 673        vars[expr]
 674        """
 675        return _pywrapcp.Solver_Element(self, *args)
 676
 677    def IndexExpression(self, vars, value):
 678        r"""
 679        Returns the expression expr such that vars[expr] == value.
 680        It assumes that vars are all different.
 681        """
 682        return _pywrapcp.Solver_IndexExpression(self, vars, value)
 683
 684    def Min(self, *args):
 685        r"""
 686        *Overload 1:*
 687        std::min(vars)
 688
 689        |
 690
 691        *Overload 2:*
 692        std::min (left, right)
 693
 694        |
 695
 696        *Overload 3:*
 697        std::min(expr, value)
 698
 699        |
 700
 701        *Overload 4:*
 702        std::min(expr, value)
 703        """
 704        return _pywrapcp.Solver_Min(self, *args)
 705
 706    def Max(self, *args):
 707        r"""
 708        *Overload 1:*
 709        std::max(vars)
 710
 711        |
 712
 713        *Overload 2:*
 714        std::max(left, right)
 715
 716        |
 717
 718        *Overload 3:*
 719        std::max(expr, value)
 720
 721        |
 722
 723        *Overload 4:*
 724        std::max(expr, value)
 725        """
 726        return _pywrapcp.Solver_Max(self, *args)
 727
 728    def ConvexPiecewiseExpr(self, expr, early_cost, early_date, late_date, late_cost):
 729        r""" Convex piecewise function."""
 730        return _pywrapcp.Solver_ConvexPiecewiseExpr(self, expr, early_cost, early_date, late_date, late_cost)
 731
 732    def SemiContinuousExpr(self, expr, fixed_charge, step):
 733        r"""
 734        Semi continuous Expression (x <= 0 -> f(x) = 0; x > 0 -> f(x) = ax + b)
 735        a >= 0 and b >= 0
 736        """
 737        return _pywrapcp.Solver_SemiContinuousExpr(self, expr, fixed_charge, step)
 738
 739    def ConditionalExpression(self, condition, expr, unperformed_value):
 740        r""" Conditional Expr condition ? expr : unperformed_value"""
 741        return _pywrapcp.Solver_ConditionalExpression(self, condition, expr, unperformed_value)
 742
 743    def TrueConstraint(self):
 744        r""" This constraint always succeeds."""
 745        return _pywrapcp.Solver_TrueConstraint(self)
 746
 747    def FalseConstraint(self, *args):
 748        return _pywrapcp.Solver_FalseConstraint(self, *args)
 749
 750    def IsEqualCstCt(self, var, value, boolvar):
 751        r""" boolvar == (var == value)"""
 752        return _pywrapcp.Solver_IsEqualCstCt(self, var, value, boolvar)
 753
 754    def IsEqualCstVar(self, var, value):
 755        r""" status var of (var == value)"""
 756        return _pywrapcp.Solver_IsEqualCstVar(self, var, value)
 757
 758    def IsEqualCt(self, v1, v2, b):
 759        r""" b == (v1 == v2)"""
 760        return _pywrapcp.Solver_IsEqualCt(self, v1, v2, b)
 761
 762    def IsEqualVar(self, v1, v2):
 763        r""" status var of (v1 == v2)"""
 764        return _pywrapcp.Solver_IsEqualVar(self, v1, v2)
 765
 766    def IsDifferentCstCt(self, var, value, boolvar):
 767        r""" boolvar == (var != value)"""
 768        return _pywrapcp.Solver_IsDifferentCstCt(self, var, value, boolvar)
 769
 770    def IsDifferentCstVar(self, var, value):
 771        r""" status var of (var != value)"""
 772        return _pywrapcp.Solver_IsDifferentCstVar(self, var, value)
 773
 774    def IsDifferentVar(self, v1, v2):
 775        r""" status var of (v1 != v2)"""
 776        return _pywrapcp.Solver_IsDifferentVar(self, v1, v2)
 777
 778    def IsDifferentCt(self, v1, v2, b):
 779        r""" b == (v1 != v2)"""
 780        return _pywrapcp.Solver_IsDifferentCt(self, v1, v2, b)
 781
 782    def IsLessOrEqualCstCt(self, var, value, boolvar):
 783        r""" boolvar == (var <= value)"""
 784        return _pywrapcp.Solver_IsLessOrEqualCstCt(self, var, value, boolvar)
 785
 786    def IsLessOrEqualCstVar(self, var, value):
 787        r""" status var of (var <= value)"""
 788        return _pywrapcp.Solver_IsLessOrEqualCstVar(self, var, value)
 789
 790    def IsLessOrEqualVar(self, left, right):
 791        r""" status var of (left <= right)"""
 792        return _pywrapcp.Solver_IsLessOrEqualVar(self, left, right)
 793
 794    def IsLessOrEqualCt(self, left, right, b):
 795        r""" b == (left <= right)"""
 796        return _pywrapcp.Solver_IsLessOrEqualCt(self, left, right, b)
 797
 798    def IsGreaterOrEqualCstCt(self, var, value, boolvar):
 799        r""" boolvar == (var >= value)"""
 800        return _pywrapcp.Solver_IsGreaterOrEqualCstCt(self, var, value, boolvar)
 801
 802    def IsGreaterOrEqualCstVar(self, var, value):
 803        r""" status var of (var >= value)"""
 804        return _pywrapcp.Solver_IsGreaterOrEqualCstVar(self, var, value)
 805
 806    def IsGreaterOrEqualVar(self, left, right):
 807        r""" status var of (left >= right)"""
 808        return _pywrapcp.Solver_IsGreaterOrEqualVar(self, left, right)
 809
 810    def IsGreaterOrEqualCt(self, left, right, b):
 811        r""" b == (left >= right)"""
 812        return _pywrapcp.Solver_IsGreaterOrEqualCt(self, left, right, b)
 813
 814    def IsGreaterCstCt(self, v, c, b):
 815        r""" b == (v > c)"""
 816        return _pywrapcp.Solver_IsGreaterCstCt(self, v, c, b)
 817
 818    def IsGreaterCstVar(self, var, value):
 819        r""" status var of (var > value)"""
 820        return _pywrapcp.Solver_IsGreaterCstVar(self, var, value)
 821
 822    def IsGreaterVar(self, left, right):
 823        r""" status var of (left > right)"""
 824        return _pywrapcp.Solver_IsGreaterVar(self, left, right)
 825
 826    def IsGreaterCt(self, left, right, b):
 827        r""" b == (left > right)"""
 828        return _pywrapcp.Solver_IsGreaterCt(self, left, right, b)
 829
 830    def IsLessCstCt(self, v, c, b):
 831        r""" b == (v < c)"""
 832        return _pywrapcp.Solver_IsLessCstCt(self, v, c, b)
 833
 834    def IsLessCstVar(self, var, value):
 835        r""" status var of (var < value)"""
 836        return _pywrapcp.Solver_IsLessCstVar(self, var, value)
 837
 838    def IsLessVar(self, left, right):
 839        r""" status var of (left < right)"""
 840        return _pywrapcp.Solver_IsLessVar(self, left, right)
 841
 842    def IsLessCt(self, left, right, b):
 843        r""" b == (left < right)"""
 844        return _pywrapcp.Solver_IsLessCt(self, left, right, b)
 845
 846    def SumLessOrEqual(self, vars, cst):
 847        r""" Variation on arrays."""
 848        return _pywrapcp.Solver_SumLessOrEqual(self, vars, cst)
 849
 850    def SumGreaterOrEqual(self, vars, cst):
 851        return _pywrapcp.Solver_SumGreaterOrEqual(self, vars, cst)
 852
 853    def SumEquality(self, *args):
 854        return _pywrapcp.Solver_SumEquality(self, *args)
 855
 856    def ScalProdEquality(self, *args):
 857        return _pywrapcp.Solver_ScalProdEquality(self, *args)
 858
 859    def ScalProdGreaterOrEqual(self, *args):
 860        return _pywrapcp.Solver_ScalProdGreaterOrEqual(self, *args)
 861
 862    def ScalProdLessOrEqual(self, *args):
 863        return _pywrapcp.Solver_ScalProdLessOrEqual(self, *args)
 864
 865    def MinEquality(self, vars, min_var):
 866        return _pywrapcp.Solver_MinEquality(self, vars, min_var)
 867
 868    def MaxEquality(self, vars, max_var):
 869        return _pywrapcp.Solver_MaxEquality(self, vars, max_var)
 870
 871    def ElementEquality(self, *args):
 872        return _pywrapcp.Solver_ElementEquality(self, *args)
 873
 874    def AbsEquality(self, var, abs_var):
 875        r""" Creates the constraint abs(var) == abs_var."""
 876        return _pywrapcp.Solver_AbsEquality(self, var, abs_var)
 877
 878    def IndexOfConstraint(self, vars, index, target):
 879        r"""
 880        This constraint is a special case of the element constraint with
 881        an array of integer variables, where the variables are all
 882        different and the index variable is constrained such that
 883        vars[index] == target.
 884        """
 885        return _pywrapcp.Solver_IndexOfConstraint(self, vars, index, target)
 886
 887    def ConstraintInitialPropagateCallback(self, ct):
 888        r"""
 889        This method is a specialized case of the MakeConstraintDemon
 890        method to call the InitiatePropagate of the constraint 'ct'.
 891        """
 892        return _pywrapcp.Solver_ConstraintInitialPropagateCallback(self, ct)
 893
 894    def DelayedConstraintInitialPropagateCallback(self, ct):
 895        r"""
 896        This method is a specialized case of the MakeConstraintDemon
 897        method to call the InitiatePropagate of the constraint 'ct' with
 898        low priority.
 899        """
 900        return _pywrapcp.Solver_DelayedConstraintInitialPropagateCallback(self, ct)
 901
 902    def ClosureDemon(self, closure):
 903        r""" Creates a demon from a closure."""
 904        return _pywrapcp.Solver_ClosureDemon(self, closure)
 905
 906    def BetweenCt(self, expr, l, u):
 907        r""" (l <= expr <= u)"""
 908        return _pywrapcp.Solver_BetweenCt(self, expr, l, u)
 909
 910    def IsBetweenCt(self, expr, l, u, b):
 911        r""" b == (l <= expr <= u)"""
 912        return _pywrapcp.Solver_IsBetweenCt(self, expr, l, u, b)
 913
 914    def IsBetweenVar(self, v, l, u):
 915        return _pywrapcp.Solver_IsBetweenVar(self, v, l, u)
 916
 917    def MemberCt(self, *args):
 918        return _pywrapcp.Solver_MemberCt(self, *args)
 919
 920    def NotMemberCt(self, *args):
 921        r"""
 922        *Overload 1:*
 923        expr not in set.
 924
 925        |
 926
 927        *Overload 2:*
 928        expr should not be in the list of forbidden intervals [start[i]..end[i]].
 929
 930        |
 931
 932        *Overload 3:*
 933        expr should not be in the list of forbidden intervals [start[i]..end[i]].
 934        """
 935        return _pywrapcp.Solver_NotMemberCt(self, *args)
 936
 937    def IsMemberCt(self, *args):
 938        return _pywrapcp.Solver_IsMemberCt(self, *args)
 939
 940    def IsMemberVar(self, *args):
 941        return _pywrapcp.Solver_IsMemberVar(self, *args)
 942
 943    def Count(self, *args):
 944        r"""
 945        *Overload 1:*
 946        |{i | vars[i] == value}| == max_count
 947
 948        |
 949
 950        *Overload 2:*
 951        |{i | vars[i] == value}| == max_count
 952        """
 953        return _pywrapcp.Solver_Count(self, *args)
 954
 955    def Distribute(self, *args):
 956        r"""
 957        *Overload 1:*
 958        Aggregated version of count:  |{i | v[i] == values[j]}| == cards[j]
 959
 960        |
 961
 962        *Overload 2:*
 963        Aggregated version of count:  |{i | v[i] == values[j]}| == cards[j]
 964
 965        |
 966
 967        *Overload 3:*
 968        Aggregated version of count:  |{i | v[i] == j}| == cards[j]
 969
 970        |
 971
 972        *Overload 4:*
 973        Aggregated version of count with bounded cardinalities:
 974        forall j in 0 .. card_size - 1: card_min <= |{i | v[i] == j}| <= card_max
 975
 976        |
 977
 978        *Overload 5:*
 979        Aggregated version of count with bounded cardinalities:
 980        forall j in 0 .. card_size - 1:
 981           card_min[j] <= |{i | v[i] == j}| <= card_max[j]
 982
 983        |
 984
 985        *Overload 6:*
 986        Aggregated version of count with bounded cardinalities:
 987        forall j in 0 .. card_size - 1:
 988           card_min[j] <= |{i | v[i] == j}| <= card_max[j]
 989
 990        |
 991
 992        *Overload 7:*
 993        Aggregated version of count with bounded cardinalities:
 994        forall j in 0 .. card_size - 1:
 995           card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j]
 996
 997        |
 998
 999        *Overload 8:*
1000        Aggregated version of count with bounded cardinalities:
1001        forall j in 0 .. card_size - 1:
1002           card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j]
1003        """
1004        return _pywrapcp.Solver_Distribute(self, *args)
1005
1006    def Deviation(self, vars, deviation_var, total_sum):
1007        r"""
1008        Deviation constraint:
1009        sum_i |n * vars[i] - total_sum| <= deviation_var and
1010        sum_i vars[i] == total_sum
1011        n = #vars
1012        """
1013        return _pywrapcp.Solver_Deviation(self, vars, deviation_var, total_sum)
1014
1015    def AllDifferent(self, *args):
1016        r"""
1017        *Overload 1:*
1018        All variables are pairwise different. This corresponds to the
1019        stronger version of the propagation algorithm.
1020
1021        |
1022
1023        *Overload 2:*
1024        All variables are pairwise different.  If 'stronger_propagation'
1025        is true, stronger, and potentially slower propagation will
1026        occur. This API will be deprecated in the future.
1027        """
1028        return _pywrapcp.Solver_AllDifferent(self, *args)
1029
1030    def AllDifferentExcept(self, vars, escape_value):
1031        r"""
1032        All variables are pairwise different, unless they are assigned to
1033        the escape value.
1034        """
1035        return _pywrapcp.Solver_AllDifferentExcept(self, vars, escape_value)
1036
1037    def SortingConstraint(self, vars, sorted):
1038        r"""
1039        Creates a constraint binding the arrays of variables "vars" and
1040        "sorted_vars": sorted_vars[0] must be equal to the minimum of all
1041        variables in vars, and so on: the value of sorted_vars[i] must be
1042        equal to the i-th value of variables invars.
1043
1044        This constraint propagates in both directions: from "vars" to
1045        "sorted_vars" and vice-versa.
1046
1047        Behind the scenes, this constraint maintains that:
1048          - sorted is always increasing.
1049          - whatever the values of vars, there exists a permutation that
1050            injects its values into the sorted variables.
1051
1052        For more info, please have a look at:
1053          https://mpi-inf.mpg.de/~mehlhorn/ftp/Mehlhorn-Thiel.pdf
1054        """
1055        return _pywrapcp.Solver_SortingConstraint(self, vars, sorted)
1056
1057    def LexicalLess(self, left, right):
1058        r"""
1059        Creates a constraint that enforces that left is lexicographically less
1060        than right.
1061        """
1062        return _pywrapcp.Solver_LexicalLess(self, left, right)
1063
1064    def LexicalLessOrEqual(self, left, right):
1065        r"""
1066        Creates a constraint that enforces that left is lexicographically less
1067        than or equal to right.
1068        """
1069        return _pywrapcp.Solver_LexicalLessOrEqual(self, left, right)
1070
1071    def InversePermutationConstraint(self, left, right):
1072        r"""
1073        Creates a constraint that enforces that 'left' and 'right' both
1074        represent permutations of [0..left.size()-1], and that 'right' is
1075        the inverse permutation of 'left', i.e. for all i in
1076        [0..left.size()-1], right[left[i]] = i.
1077        """
1078        return _pywrapcp.Solver_InversePermutationConstraint(self, left, right)
1079
1080    def NullIntersect(self, first_vars, second_vars):
1081        r"""
1082        Creates a constraint that states that all variables in the first
1083        vector are different from all variables in the second
1084        group. Thus the set of values in the first vector does not
1085        intersect with the set of values in the second vector.
1086        """
1087        return _pywrapcp.Solver_NullIntersect(self, first_vars, second_vars)
1088
1089    def NullIntersectExcept(self, first_vars, second_vars, escape_value):
1090        r"""
1091        Creates a constraint that states that all variables in the first
1092        vector are different from all variables from the second group,
1093        unless they are assigned to the escape value. Thus the set of
1094        values in the first vector minus the escape value does not
1095        intersect with the set of values in the second vector.
1096        """
1097        return _pywrapcp.Solver_NullIntersectExcept(self, first_vars, second_vars, escape_value)
1098
1099    def Circuit(self, nexts):
1100        r""" Force the "nexts" variable to create a complete Hamiltonian path."""
1101        return _pywrapcp.Solver_Circuit(self, nexts)
1102
1103    def SubCircuit(self, nexts):
1104        r"""
1105        Force the "nexts" variable to create a complete Hamiltonian path
1106        for those that do not loop upon themselves.
1107        """
1108        return _pywrapcp.Solver_SubCircuit(self, nexts)
1109
1110    def DelayedPathCumul(self, nexts, active, cumuls, transits):
1111        r"""
1112        Delayed version of the same constraint: propagation on the nexts variables
1113        is delayed until all constraints have propagated.
1114        """
1115        return _pywrapcp.Solver_DelayedPathCumul(self, nexts, active, cumuls, transits)
1116
1117    def PathCumul(self, *args):
1118        r"""
1119        *Overload 1:*
1120        Creates a constraint which accumulates values along a path such that:
1121        cumuls[next[i]] = cumuls[i] + transits[i].
1122        Active variables indicate if the corresponding next variable is active;
1123        this could be useful to model unperformed nodes in a routing problem.
1124
1125        |
1126
1127        *Overload 2:*
1128        Creates a constraint which accumulates values along a path such that:
1129        cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]).
1130        Active variables indicate if the corresponding next variable is active;
1131        this could be useful to model unperformed nodes in a routing problem.
1132        Ownership of transit_evaluator is taken and it must be a repeatable
1133        callback.
1134
1135        |
1136
1137        *Overload 3:*
1138        Creates a constraint which accumulates values along a path such that:
1139        cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]) + slacks[i].
1140        Active variables indicate if the corresponding next variable is active;
1141        this could be useful to model unperformed nodes in a routing problem.
1142        Ownership of transit_evaluator is taken and it must be a repeatable
1143        callback.
1144        """
1145        return _pywrapcp.Solver_PathCumul(self, *args)
1146
1147    def AllowedAssignments(self, *args):
1148        r"""
1149        *Overload 1:*
1150        This method creates a constraint where the graph of the relation
1151        between the variables is given in extension. There are 'arity'
1152        variables involved in the relation and the graph is given by a
1153        integer tuple set.
1154
1155        |
1156
1157        *Overload 2:*
1158        Compatibility layer for Python API.
1159        """
1160        return _pywrapcp.Solver_AllowedAssignments(self, *args)
1161
1162    def TransitionConstraint(self, *args):
1163        return _pywrapcp.Solver_TransitionConstraint(self, *args)
1164
1165    def NonOverlappingBoxesConstraint(self, *args):
1166        return _pywrapcp.Solver_NonOverlappingBoxesConstraint(self, *args)
1167
1168    def Pack(self, vars, number_of_bins):
1169        r"""
1170        This constraint packs all variables onto 'number_of_bins'
1171        variables.  For any given variable, a value of 'number_of_bins'
1172        indicates that the variable is not assigned to any bin.
1173        Dimensions, i.e., cumulative constraints on this packing, can be
1174        added directly from the pack class.
1175        """
1176        return _pywrapcp.Solver_Pack(self, vars, number_of_bins)
1177
1178    def FixedDurationIntervalVar(self, *args):
1179        r"""
1180        *Overload 1:*
1181        Creates an interval var with a fixed duration. The duration must
1182        be greater than 0. If optional is true, then the interval can be
1183        performed or unperformed. If optional is false, then the interval
1184        is always performed.
1185
1186        |
1187
1188        *Overload 2:*
1189        Creates a performed interval var with a fixed duration. The duration must
1190        be greater than 0.
1191
1192        |
1193
1194        *Overload 3:*
1195        Creates an interval var with a fixed duration, and performed_variable.
1196        The duration must be greater than 0.
1197        """
1198        return _pywrapcp.Solver_FixedDurationIntervalVar(self, *args)
1199
1200    def FixedInterval(self, start, duration, name):
1201        r""" Creates a fixed and performed interval."""
1202        return _pywrapcp.Solver_FixedInterval(self, start, duration, name)
1203
1204    def IntervalVar(self, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name):
1205        r"""
1206        Creates an interval var by specifying the bounds on start,
1207        duration, and end.
1208        """
1209        return _pywrapcp.Solver_IntervalVar(self, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name)
1210
1211    def MirrorInterval(self, interval_var):
1212        r"""
1213        Creates an interval var that is the mirror image of the given one, that
1214        is, the interval var obtained by reversing the axis.
1215        """
1216        return _pywrapcp.Solver_MirrorInterval(self, interval_var)
1217
1218    def FixedDurationStartSyncedOnStartIntervalVar(self, interval_var, duration, offset):
1219        r"""
1220        Creates an interval var with a fixed duration whose start is
1221        synchronized with the start of another interval, with a given
1222        offset. The performed status is also in sync with the performed
1223        status of the given interval variable.
1224        """
1225        return _pywrapcp.Solver_FixedDurationStartSyncedOnStartIntervalVar(self, interval_var, duration, offset)
1226
1227    def FixedDurationStartSyncedOnEndIntervalVar(self, interval_var, duration, offset):
1228        r"""
1229        Creates an interval var with a fixed duration whose start is
1230        synchronized with the end of another interval, with a given
1231        offset. The performed status is also in sync with the performed
1232        status of the given interval variable.
1233        """
1234        return _pywrapcp.Solver_FixedDurationStartSyncedOnEndIntervalVar(self, interval_var, duration, offset)
1235
1236    def FixedDurationEndSyncedOnStartIntervalVar(self, interval_var, duration, offset):
1237        r"""
1238        Creates an interval var with a fixed duration whose end is
1239        synchronized with the start of another interval, with a given
1240        offset. The performed status is also in sync with the performed
1241        status of the given interval variable.
1242        """
1243        return _pywrapcp.Solver_FixedDurationEndSyncedOnStartIntervalVar(self, interval_var, duration, offset)
1244
1245    def FixedDurationEndSyncedOnEndIntervalVar(self, interval_var, duration, offset):
1246        r"""
1247        Creates an interval var with a fixed duration whose end is
1248        synchronized with the end of another interval, with a given
1249        offset. The performed status is also in sync with the performed
1250        status of the given interval variable.
1251        """
1252        return _pywrapcp.Solver_FixedDurationEndSyncedOnEndIntervalVar(self, interval_var, duration, offset)
1253
1254    def IntervalRelaxedMin(self, interval_var):
1255        r"""
1256         Creates and returns an interval variable that wraps around the given one,
1257         relaxing the min start and end. Relaxing means making unbounded when
1258         optional. If the variable is non-optional, this method returns
1259         interval_var.
1260
1261         More precisely, such an interval variable behaves as follows:
1262        When the underlying must be performed, the returned interval variable
1263             behaves exactly as the underlying;
1264        When the underlying may or may not be performed, the returned interval
1265             variable behaves like the underlying, except that it is unbounded on
1266             the min side;
1267        When the underlying cannot be performed, the returned interval variable
1268             is of duration 0 and must be performed in an interval unbounded on
1269             both sides.
1270
1271         This is very useful to implement propagators that may only modify
1272         the start max or end max.
1273        """
1274        return _pywrapcp.Solver_IntervalRelaxedMin(self, interval_var)
1275
1276    def IntervalRelaxedMax(self, interval_var):
1277        r"""
1278         Creates and returns an interval variable that wraps around the given one,
1279         relaxing the max start and end. Relaxing means making unbounded when
1280         optional. If the variable is non optional, this method returns
1281         interval_var.
1282
1283         More precisely, such an interval variable behaves as follows:
1284        When the underlying must be performed, the returned interval variable
1285             behaves exactly as the underlying;
1286        When the underlying may or may not be performed, the returned interval
1287             variable behaves like the underlying, except that it is unbounded on
1288             the max side;
1289        When the underlying cannot be performed, the returned interval variable
1290             is of duration 0 and must be performed in an interval unbounded on
1291             both sides.
1292
1293         This is very useful for implementing propagators that may only modify
1294         the start min or end min.
1295        """
1296        return _pywrapcp.Solver_IntervalRelaxedMax(self, interval_var)
1297
1298    def TemporalDisjunction(self, *args):
1299        r"""
1300        *Overload 1:*
1301        This constraint implements a temporal disjunction between two
1302        interval vars t1 and t2. 'alt' indicates which alternative was
1303        chosen (alt == 0 is equivalent to t1 before t2).
1304
1305        |
1306
1307        *Overload 2:*
1308        This constraint implements a temporal disjunction between two
1309        interval vars.
1310        """
1311        return _pywrapcp.Solver_TemporalDisjunction(self, *args)
1312
1313    def DisjunctiveConstraint(self, intervals, name):
1314        r"""
1315        This constraint forces all interval vars into an non-overlapping
1316        sequence. Intervals with zero duration can be scheduled anywhere.
1317        """
1318        return _pywrapcp.Solver_DisjunctiveConstraint(self, intervals, name)
1319
1320    def Cumulative(self, *args):
1321        r"""
1322        *Overload 1:*
1323        This constraint forces that, for any integer t, the sum of the demands
1324        corresponding to an interval containing t does not exceed the given
1325        capacity.
1326
1327        Intervals and demands should be vectors of equal size.
1328
1329        Demands should only contain non-negative values. Zero values are
1330        supported, and the corresponding intervals are filtered out, as they
1331        neither impact nor are impacted by this constraint.
1332
1333        |
1334
1335        *Overload 2:*
1336        This constraint forces that, for any integer t, the sum of the demands
1337        corresponding to an interval containing t does not exceed the given
1338        capacity.
1339
1340        Intervals and demands should be vectors of equal size.
1341
1342        Demands should only contain non-negative values. Zero values are
1343        supported, and the corresponding intervals are filtered out, as they
1344        neither impact nor are impacted by this constraint.
1345
1346        |
1347
1348        *Overload 3:*
1349        This constraint forces that, for any integer t, the sum of the demands
1350        corresponding to an interval containing t does not exceed the given
1351        capacity.
1352
1353        Intervals and demands should be vectors of equal size.
1354
1355        Demands should only contain non-negative values. Zero values are
1356        supported, and the corresponding intervals are filtered out, as they
1357        neither impact nor are impacted by this constraint.
1358
1359        |
1360
1361        *Overload 4:*
1362        This constraint enforces that, for any integer t, the sum of the demands
1363        corresponding to an interval containing t does not exceed the given
1364        capacity.
1365
1366        Intervals and demands should be vectors of equal size.
1367
1368        Demands should only contain non-negative values. Zero values are
1369        supported, and the corresponding intervals are filtered out, as they
1370        neither impact nor are impacted by this constraint.
1371
1372        |
1373
1374        *Overload 5:*
1375        This constraint enforces that, for any integer t, the sum of demands
1376        corresponding to an interval containing t does not exceed the given
1377        capacity.
1378
1379        Intervals and demands should be vectors of equal size.
1380
1381        Demands should be positive.
1382
1383        |
1384
1385        *Overload 6:*
1386        This constraint enforces that, for any integer t, the sum of demands
1387        corresponding to an interval containing t does not exceed the given
1388        capacity.
1389
1390        Intervals and demands should be vectors of equal size.
1391
1392        Demands should be positive.
1393        """
1394        return _pywrapcp.Solver_Cumulative(self, *args)
1395
1396    def Cover(self, vars, target_var):
1397        r"""
1398        This constraint states that the target_var is the convex hull of
1399        the intervals. If none of the interval variables is performed,
1400        then the target var is unperformed too. Also, if the target
1401        variable is unperformed, then all the intervals variables are
1402        unperformed too.
1403        """
1404        return _pywrapcp.Solver_Cover(self, vars, target_var)
1405
1406    def Assignment(self, *args):
1407        r"""
1408        *Overload 1:*
1409        This method creates an empty assignment.
1410
1411        |
1412
1413        *Overload 2:*
1414        This method creates an assignment which is a copy of 'a'.
1415        """
1416        return _pywrapcp.Solver_Assignment(self, *args)
1417
1418    def FirstSolutionCollector(self, *args):
1419        r"""
1420        *Overload 1:*
1421        Collect the first solution of the search.
1422
1423        |
1424
1425        *Overload 2:*
1426        Collect the first solution of the search. The variables will need to
1427        be added later.
1428        """
1429        return _pywrapcp.Solver_FirstSolutionCollector(self, *args)
1430
1431    def LastSolutionCollector(self, *args):
1432        r"""
1433        *Overload 1:*
1434        Collect the last solution of the search.
1435
1436        |
1437
1438        *Overload 2:*
1439        Collect the last solution of the search. The variables will need to
1440        be added later.
1441        """
1442        return _pywrapcp.Solver_LastSolutionCollector(self, *args)
1443
1444    def BestValueSolutionCollector(self, *args):
1445        r"""
1446        *Overload 1:*
1447        Collect the solution corresponding to the optimal value of the objective
1448        of 'assignment'; if 'assignment' does not have an objective no solution is
1449        collected. This collector only collects one solution corresponding to the
1450        best objective value (the first one found).
1451
1452        |
1453
1454        *Overload 2:*
1455        Collect the solution corresponding to the optimal value of the
1456        objective of the internal assignment; if this assignment does not have an
1457        objective no solution is collected. This collector only collects one
1458        solution corresponding to the best objective value (the first one found).
1459        The variables and objective(s) will need to be added later.
1460        """
1461        return _pywrapcp.Solver_BestValueSolutionCollector(self, *args)
1462
1463    def AllSolutionCollector(self, *args):
1464        r"""
1465        *Overload 1:*
1466        Collect all solutions of the search.
1467
1468        |
1469
1470        *Overload 2:*
1471        Collect all solutions of the search. The variables will need to
1472        be added later.
1473        """
1474        return _pywrapcp.Solver_AllSolutionCollector(self, *args)
1475
1476    def Minimize(self, v, step):
1477        r""" Creates a minimization objective."""
1478        return _pywrapcp.Solver_Minimize(self, v, step)
1479
1480    def Maximize(self, v, step):
1481        r""" Creates a maximization objective."""
1482        return _pywrapcp.Solver_Maximize(self, v, step)
1483
1484    def Optimize(self, maximize, v, step):
1485        r""" Creates a objective with a given sense (true = maximization)."""
1486        return _pywrapcp.Solver_Optimize(self, maximize, v, step)
1487
1488    def WeightedMinimize(self, *args):
1489        r"""
1490        *Overload 1:*
1491        Creates a minimization weighted objective. The actual objective is
1492        scalar_prod(sub_objectives, weights).
1493
1494        |
1495
1496        *Overload 2:*
1497        Creates a minimization weighted objective. The actual objective is
1498        scalar_prod(sub_objectives, weights).
1499        """
1500        return _pywrapcp.Solver_WeightedMinimize(self, *args)
1501
1502    def WeightedMaximize(self, *args):
1503        r"""
1504        *Overload 1:*
1505        Creates a maximization weigthed objective.
1506
1507        |
1508
1509        *Overload 2:*
1510        Creates a maximization weigthed objective.
1511        """
1512        return _pywrapcp.Solver_WeightedMaximize(self, *args)
1513
1514    def WeightedOptimize(self, *args):
1515        r"""
1516        *Overload 1:*
1517        Creates a weighted objective with a given sense (true = maximization).
1518
1519        |
1520
1521        *Overload 2:*
1522        Creates a weighted objective with a given sense (true = maximization).
1523        """
1524        return _pywrapcp.Solver_WeightedOptimize(self, *args)
1525
1526    def TabuSearch(self, maximize, objective, step, vars, keep_tenure, forbid_tenure, tabu_factor):
1527        r"""
1528        MetaHeuristics which try to get the search out of local optima.
1529        Creates a Tabu Search monitor.
1530        In the context of local search the behavior is similar to MakeOptimize(),
1531        creating an objective in a given sense. The behavior differs once a local
1532        optimum is reached: thereafter solutions which degrade the value of the
1533        objective are allowed if they are not "tabu". A solution is "tabu" if it
1534        doesn't respect the following rules:
1535        - improving the best solution found so far
1536        - variables in the "keep" list must keep their value, variables in the
1537        "forbid" list must not take the value they have in the list.
1538        Variables with new values enter the tabu lists after each new solution
1539        found and leave the lists after a given number of iterations (called
1540        tenure). Only the variables passed to the method can enter the lists.
1541        The tabu criterion is softened by the tabu factor which gives the number
1542        of "tabu" violations which is tolerated; a factor of 1 means no violations
1543        allowed; a factor of 0 means all violations are allowed.
1544        """
1545        return _pywrapcp.Solver_TabuSearch(self, maximize, objective, step, vars, keep_tenure, forbid_tenure, tabu_factor)
1546
1547    def SimulatedAnnealing(self, maximize, v, step, initial_temperature):
1548        r""" Creates a Simulated Annealing monitor."""
1549        return _pywrapcp.Solver_SimulatedAnnealing(self, maximize, v, step, initial_temperature)
1550
1551    def LubyRestart(self, scale_factor):
1552        r"""
1553        This search monitor will restart the search periodically.
1554        At the iteration n, it will restart after scale_factor * Luby(n) failures
1555        where Luby is the Luby Strategy (i.e. 1 1 2 1 1 2 4 1 1 2 1 1 2 4 8...).
1556        """
1557        return _pywrapcp.Solver_LubyRestart(self, scale_factor)
1558
1559    def ConstantRestart(self, frequency):
1560        r"""
1561        This search monitor will restart the search periodically after 'frequency'
1562        failures.
1563        """
1564        return _pywrapcp.Solver_ConstantRestart(self, frequency)
1565
1566    def TimeLimit(self, *args):
1567        return _pywrapcp.Solver_TimeLimit(self, *args)
1568
1569    def BranchesLimit(self, branches):
1570        r"""
1571        Creates a search limit that constrains the number of branches
1572        explored in the search tree.
1573        """
1574        return _pywrapcp.Solver_BranchesLimit(self, branches)
1575
1576    def FailuresLimit(self, failures):
1577        r"""
1578        Creates a search limit that constrains the number of failures
1579        that can happen when exploring the search tree.
1580        """
1581        return _pywrapcp.Solver_FailuresLimit(self, failures)
1582
1583    def SolutionsLimit(self, solutions):
1584        r"""
1585        Creates a search limit that constrains the number of solutions found
1586        during the search.
1587        """
1588        return _pywrapcp.Solver_SolutionsLimit(self, solutions)
1589
1590    def Limit(self, *args):
1591        r"""
1592        *Overload 1:*
1593        Limits the search with the 'time', 'branches', 'failures' and
1594        'solutions' limits. 'smart_time_check' reduces the calls to the wall
1595
1596        |
1597
1598        *Overload 2:*
1599        Creates a search limit from its protobuf description
1600
1601        |
1602
1603        *Overload 3:*
1604        Creates a search limit that is reached when either of the underlying limit
1605        is reached. That is, the returned limit is more stringent than both
1606        argument limits.
1607        """
1608        return _pywrapcp.Solver_Limit(self, *args)
1609
1610    def CustomLimit(self, limiter):
1611        r"""
1612        Callback-based search limit. Search stops when limiter returns true; if
1613        this happens at a leaf the corresponding solution will be rejected.
1614        """
1615        return _pywrapcp.Solver_CustomLimit(self, limiter)
1616
1617    def SearchLog(self, *args):
1618        return _pywrapcp.Solver_SearchLog(self, *args)
1619
1620    def SearchTrace(self, prefix):
1621        r"""
1622        Creates a search monitor that will trace precisely the behavior of the
1623        search. Use this only for low level debugging.
1624        """
1625        return _pywrapcp.Solver_SearchTrace(self, prefix)
1626
1627    def PrintModelVisitor(self):
1628        r""" Prints the model."""
1629        return _pywrapcp.Solver_PrintModelVisitor(self)
1630
1631    def StatisticsModelVisitor(self):
1632        r""" Displays some nice statistics on the model."""
1633        return _pywrapcp.Solver_StatisticsModelVisitor(self)
1634
1635    def AssignVariableValue(self, var, val):
1636        r""" Decisions."""
1637        return _pywrapcp.Solver_AssignVariableValue(self, var, val)
1638
1639    def VariableLessOrEqualValue(self, var, value):
1640        return _pywrapcp.Solver_VariableLessOrEqualValue(self, var, value)
1641
1642    def VariableGreaterOrEqualValue(self, var, value):
1643        return _pywrapcp.Solver_VariableGreaterOrEqualValue(self, var, value)
1644
1645    def SplitVariableDomain(self, var, val, start_with_lower_half):
1646        return _pywrapcp.Solver_SplitVariableDomain(self, var, val, start_with_lower_half)
1647
1648    def AssignVariableValueOrFail(self, var, value):
1649        return _pywrapcp.Solver_AssignVariableValueOrFail(self, var, value)
1650
1651    def AssignVariablesValues(self, vars, values):
1652        return _pywrapcp.Solver_AssignVariablesValues(self, vars, values)
1653
1654    def FailDecision(self):
1655        return _pywrapcp.Solver_FailDecision(self)
1656
1657    def Decision(self, apply, refute):
1658        return _pywrapcp.Solver_Decision(self, apply, refute)
1659
1660    def Compose(self, dbs):
1661        return _pywrapcp.Solver_Compose(self, dbs)
1662
1663    def Try(self, dbs):
1664        return _pywrapcp.Solver_Try(self, dbs)
1665
1666    def DefaultPhase(self, *args):
1667        return _pywrapcp.Solver_DefaultPhase(self, *args)
1668
1669    def ScheduleOrPostpone(self, var, est, marker):
1670        r"""
1671        Returns a decision that tries to schedule a task at a given time.
1672        On the Apply branch, it will set that interval var as performed and set
1673        its start to 'est'. On the Refute branch, it will just update the
1674        'marker' to 'est' + 1. This decision is used in the
1675        INTERVAL_SET_TIMES_FORWARD strategy.
1676        """
1677        return _pywrapcp.Solver_ScheduleOrPostpone(self, var, est, marker)
1678
1679    def ScheduleOrExpedite(self, var, est, marker):
1680        r"""
1681        Returns a decision that tries to schedule a task at a given time.
1682        On the Apply branch, it will set that interval var as performed and set
1683        its end to 'est'. On the Refute branch, it will just update the
1684        'marker' to 'est' - 1. This decision is used in the
1685        INTERVAL_SET_TIMES_BACKWARD strategy.
1686        """
1687        return _pywrapcp.Solver_ScheduleOrExpedite(self, var, est, marker)
1688
1689    def RankFirstInterval(self, sequence, index):
1690        r"""
1691        Returns a decision that tries to rank first the ith interval var
1692        in the sequence variable.
1693        """
1694        return _pywrapcp.Solver_RankFirstInterval(self, sequence, index)
1695
1696    def RankLastInterval(self, sequence, index):
1697        r"""
1698        Returns a decision that tries to rank last the ith interval var
1699        in the sequence variable.
1700        """
1701        return _pywrapcp.Solver_RankLastInterval(self, sequence, index)
1702
1703    def Phase(self, *args):
1704        return _pywrapcp.Solver_Phase(self, *args)
1705
1706    def DecisionBuilderFromAssignment(self, assignment, db, vars):
1707        r"""
1708        Returns a decision builder for which the left-most leaf corresponds
1709        to assignment, the rest of the tree being explored using 'db'.
1710        """
1711        return _pywrapcp.Solver_DecisionBuilderFromAssignment(self, assignment, db, vars)
1712
1713    def ConstraintAdder(self, ct):
1714        r"""
1715        Returns a decision builder that will add the given constraint to
1716        the model.
1717        """
1718        return _pywrapcp.Solver_ConstraintAdder(self, ct)
1719
1720    def SolveOnce(self, db, monitors):
1721        return _pywrapcp.Solver_SolveOnce(self, db, monitors)
1722
1723    def NestedOptimize(self, *args):
1724        return _pywrapcp.Solver_NestedOptimize(self, *args)
1725
1726    def RestoreAssignment(self, assignment):
1727        r"""
1728        Returns a DecisionBuilder which restores an Assignment
1729        (calls void Assignment::Restore())
1730        """
1731        return _pywrapcp.Solver_RestoreAssignment(self, assignment)
1732
1733    def StoreAssignment(self, assignment):
1734        r"""
1735        Returns a DecisionBuilder which stores an Assignment
1736        (calls void Assignment::Store())
1737        """
1738        return _pywrapcp.Solver_StoreAssignment(self, assignment)
1739
1740    def Operator(self, *args):
1741        return _pywrapcp.Solver_Operator(self, *args)
1742
1743    def RandomLnsOperator(self, *args):
1744        return _pywrapcp.Solver_RandomLnsOperator(self, *args)
1745
1746    def MoveTowardTargetOperator(self, *args):
1747        r"""
1748        *Overload 1:*
1749        Creates a local search operator that tries to move the assignment of some
1750        variables toward a target. The target is given as an Assignment. This
1751        operator generates neighbors in which the only difference compared to the
1752        current state is that one variable that belongs to the target assignment
1753        is set to its target value.
1754
1755        |
1756
1757        *Overload 2:*
1758        Creates a local search operator that tries to move the assignment of some
1759        variables toward a target. The target is given either as two vectors: a
1760        vector of variables and a vector of associated target values. The two
1761        vectors should be of the same length. This operator generates neighbors in
1762        which the only difference compared to the current state is that one
1763        variable that belongs to the given vector is set to its target value.
1764        """
1765        return _pywrapcp.Solver_MoveTowardTargetOperator(self, *args)
1766
1767    def ConcatenateOperators(self, *args):
1768        return _pywrapcp.Solver_ConcatenateOperators(self, *args)
1769
1770    def RandomConcatenateOperators(self, *args):
1771        r"""
1772        *Overload 1:*
1773        Randomized version of local search concatenator; calls a random operator
1774        at each call to MakeNextNeighbor().
1775
1776        |
1777
1778        *Overload 2:*
1779        Randomized version of local search concatenator; calls a random operator
1780        at each call to MakeNextNeighbor(). The provided seed is used to
1781        initialize the random number generator.
1782        """
1783        return _pywrapcp.Solver_RandomConcatenateOperators(self, *args)
1784
1785    def NeighborhoodLimit(self, op, limit):
1786        r"""
1787        Creates a local search operator that wraps another local search
1788        operator and limits the number of neighbors explored (i.e., calls
1789        to MakeNextNeighbor from the current solution (between two calls
1790        to Start()). When this limit is reached, MakeNextNeighbor()
1791        returns false. The counter is cleared when Start() is called.
1792        """
1793        return _pywrapcp.Solver_NeighborhoodLimit(self, op, limit)
1794
1795    def LocalSearchPhase(self, *args):
1796        return _pywrapcp.Solver_LocalSearchPhase(self, *args)
1797
1798    def LocalSearchPhaseParameters(self, *args):
1799        return _pywrapcp.Solver_LocalSearchPhaseParameters(self, *args)
1800
1801    def TopProgressPercent(self):
1802        r"""
1803        Returns a percentage representing the propress of the search before
1804        reaching the limits of the top-level search (can be called from a nested
1805        solve).
1806        """
1807        return _pywrapcp.Solver_TopProgressPercent(self)
1808
1809    def SearchDepth(self):
1810        r"""
1811        Gets the search depth of the current active search. Returns -1 if
1812        there is no active search opened.
1813        """
1814        return _pywrapcp.Solver_SearchDepth(self)
1815
1816    def SearchLeftDepth(self):
1817        r"""
1818        Gets the search left depth of the current active search. Returns -1 if
1819        there is no active search opened.
1820        """
1821        return _pywrapcp.Solver_SearchLeftDepth(self)
1822
1823    def SolveDepth(self):
1824        r"""
1825        Gets the number of nested searches. It returns 0 outside search,
1826        1 during the top level search, 2 or more in case of nested searches.
1827        """
1828        return _pywrapcp.Solver_SolveDepth(self)
1829
1830    def Rand64(self, size):
1831        r""" Returns a random value between 0 and 'size' - 1;"""
1832        return _pywrapcp.Solver_Rand64(self, size)
1833
1834    def Rand32(self, size):
1835        r""" Returns a random value between 0 and 'size' - 1;"""
1836        return _pywrapcp.Solver_Rand32(self, size)
1837
1838    def ReSeed(self, seed):
1839        r""" Reseed the solver random generator."""
1840        return _pywrapcp.Solver_ReSeed(self, seed)
1841
1842    def LocalSearchProfile(self):
1843        r""" Returns local search profiling information in a human readable format."""
1844        return _pywrapcp.Solver_LocalSearchProfile(self)
1845
1846    def Constraints(self):
1847        r"""
1848        Counts the number of constraints that have been added
1849        to the solver before the search.
1850        """
1851        return _pywrapcp.Solver_Constraints(self)
1852
1853    def Accept(self, visitor):
1854        r""" Accepts the given model visitor."""
1855        return _pywrapcp.Solver_Accept(self, visitor)
1856
1857    def FinishCurrentSearch(self):
1858        r""" Tells the solver to kill or restart the current search."""
1859        return _pywrapcp.Solver_FinishCurrentSearch(self)
1860
1861    def RestartCurrentSearch(self):
1862        return _pywrapcp.Solver_RestartCurrentSearch(self)
1863
1864    def ShouldFail(self):
1865        r"""
1866        These methods are only useful for the SWIG wrappers, which need a way
1867        to externally cause the Solver to fail.
1868        """
1869        return _pywrapcp.Solver_ShouldFail(self)
1870
1871    def __str__(self):
1872        return _pywrapcp.Solver___str__(self)
1873
1874    def Add(self, ct):
1875      if isinstance(ct, PyConstraint):
1876        self.__python_constraints.append(ct)
1877      self.AddConstraint(ct)
1878
1879
1880    def TreeNoCycle(self, nexts, active, callback=0):
1881        return _pywrapcp.Solver_TreeNoCycle(self, nexts, active, callback)
1882
1883    def SearchLogWithCallback(self, period, callback):
1884        return _pywrapcp.Solver_SearchLogWithCallback(self, period, callback)
1885
1886    def ElementFunction(self, values, index):
1887        return _pywrapcp.Solver_ElementFunction(self, values, index)
1888
1889    def VarEvalValStrPhase(self, vars, var_evaluator, val_str):
1890        return _pywrapcp.Solver_VarEvalValStrPhase(self, vars, var_evaluator, val_str)
1891
1892    def VarStrValEvalPhase(self, vars, var_str, val_eval):
1893        return _pywrapcp.Solver_VarStrValEvalPhase(self, vars, var_str, val_eval)
1894
1895    def VarEvalValEvalPhase(self, vars, var_eval, val_eval):
1896        return _pywrapcp.Solver_VarEvalValEvalPhase(self, vars, var_eval, val_eval)
1897
1898    def VarStrValEvalTieBreakPhase(self, vars, var_str, val_eval, tie_breaker):
1899        return _pywrapcp.Solver_VarStrValEvalTieBreakPhase(self, vars, var_str, val_eval, tie_breaker)
1900
1901    def VarEvalValEvalTieBreakPhase(self, vars, var_eval, val_eval, tie_breaker):
1902        return _pywrapcp.Solver_VarEvalValEvalTieBreakPhase(self, vars, var_eval, val_eval, tie_breaker)
1903
1904    def EvalEvalStrPhase(self, vars, evaluator, str):
1905        return _pywrapcp.Solver_EvalEvalStrPhase(self, vars, evaluator, str)
1906
1907    def EvalEvalStrTieBreakPhase(self, vars, evaluator, tie_breaker, str):
1908        return _pywrapcp.Solver_EvalEvalStrTieBreakPhase(self, vars, evaluator, tie_breaker, str)
1909
1910    def GuidedLocalSearch(self, *args):
1911        return _pywrapcp.Solver_GuidedLocalSearch(self, *args)
1912
1913    def SumObjectiveFilter(self, vars, values, filter_enum):
1914        return _pywrapcp.Solver_SumObjectiveFilter(self, vars, values, filter_enum)

Solver Class

A solver represents the main computation engine. It implements the entire range of Constraint Programming protocols:

  • Reversibility
  • Propagation
  • Search

Usually, Constraint Programming code consists of

  • the creation of the Solver,
  • the creation of the decision variables of the model,
  • the creation of the constraints of the model and their addition to the solver() through the AddConstraint() method,
  • the creation of the main DecisionBuilder class,
  • the launch of the solve() method with the decision builder.

For the time being, Solver is neither MT_SAFE nor MT_HOT.

Solver(*args)
436    def __init__(self, *args):
437        _pywrapcp.Solver_swiginit(self, _pywrapcp.new_Solver(*args))
438
439        self.__python_constraints = []
thisown

The membership flag

INT_VAR_DEFAULT = 0

The default behavior is CHOOSE_FIRST_UNBOUND.

INT_VAR_SIMPLE = 1

The simple selection is CHOOSE_FIRST_UNBOUND.

CHOOSE_FIRST_UNBOUND = 2

Select the first unbound variable. Variables are considered in the order of the vector of IntVars used to create the selector.

CHOOSE_RANDOM = 3

Randomly select one of the remaining unbound variables.

CHOOSE_MIN_SIZE_LOWEST_MIN = 4

Among unbound variables, select the variable with the smallest size, i.e., the smallest number of possible values. In case of a tie, the selected variables is the one with the lowest min value. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector.

CHOOSE_MIN_SIZE_HIGHEST_MIN = 5

Among unbound variables, select the variable with the smallest size, i.e., the smallest number of possible values. In case of a tie, the selected variable is the one with the highest min value. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector.

CHOOSE_MIN_SIZE_LOWEST_MAX = 6

Among unbound variables, select the variable with the smallest size, i.e., the smallest number of possible values. In case of a tie, the selected variables is the one with the lowest max value. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector.

CHOOSE_MIN_SIZE_HIGHEST_MAX = 7

Among unbound variables, select the variable with the smallest size, i.e., the smallest number of possible values. In case of a tie, the selected variable is the one with the highest max value. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector.

CHOOSE_LOWEST_MIN = 8

Among unbound variables, select the variable with the smallest minimal value. In case of a tie, the first one is selected, "first" defined by the order in the vector of IntVars used to create the selector.

CHOOSE_HIGHEST_MAX = 9

Among unbound variables, select the variable with the highest maximal value. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector.

CHOOSE_MIN_SIZE = 10

Among unbound variables, select the variable with the smallest size. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector.

CHOOSE_MAX_SIZE = 11

Among unbound variables, select the variable with the highest size. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector.

CHOOSE_MAX_REGRET_ON_MIN = 12

Among unbound variables, select the variable with the largest gap between the first and the second values of the domain.

CHOOSE_PATH = 13

Selects the next unbound variable on a path, the path being defined by the variables: var[i] corresponds to the index of the next of i.

INT_VALUE_DEFAULT = 0

The default behavior is ASSIGN_MIN_VALUE.

INT_VALUE_SIMPLE = 1

The simple selection is ASSIGN_MIN_VALUE.

ASSIGN_MIN_VALUE = 2

Selects the min value of the selected variable.

ASSIGN_MAX_VALUE = 3

Selects the max value of the selected variable.

ASSIGN_RANDOM_VALUE = 4

Selects randomly one of the possible values of the selected variable.

ASSIGN_CENTER_VALUE = 5

Selects the first possible value which is the closest to the center of the domain of the selected variable. The center is defined as (min + max) / 2.

SPLIT_LOWER_HALF = 6

Split the domain in two around the center, and choose the lower part first.

SPLIT_UPPER_HALF = 7

Split the domain in two around the center, and choose the lower part first.

SEQUENCE_DEFAULT = 0
SEQUENCE_SIMPLE = 1
CHOOSE_MIN_SLACK_RANK_FORWARD = 2
CHOOSE_RANDOM_RANK_FORWARD = 3
INTERVAL_DEFAULT = 0

The default is INTERVAL_SET_TIMES_FORWARD.

INTERVAL_SIMPLE = 1

The simple is INTERVAL_SET_TIMES_FORWARD.

INTERVAL_SET_TIMES_FORWARD = 2

Selects the variable with the lowest starting time of all variables, and fixes its starting time to this lowest value.

INTERVAL_SET_TIMES_BACKWARD = 3

Selects the variable with the highest ending time of all variables, and fixes the ending time to this highest values.

TWOOPT = 0

Operator which reverses a sub-chain of a path. It is called TwoOpt because it breaks two arcs on the path; resulting paths are called two-optimal. Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5 (where (1, 5) are first and last nodes of the path and can therefore not be moved): 1 -> [3 -> 2] -> 4 -> 5 1 -> [4 -> 3 -> 2] -> 5 1 -> 2 -> [4 -> 3] -> 5

OROPT = 1

Relocate: OROPT and RELOCATE. Operator which moves a sub-chain of a path to another position; the specified chain length is the fixed length of the chains being moved. When this length is 1, the operator simply moves a node to another position. Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5, for a chain length of 2 (where (1, 5) are first and last nodes of the path and can therefore not be moved): 1 -> 4 -> [2 -> 3] -> 5 1 -> [3 -> 4] -> 2 -> 5

Using Relocate with chain lengths of 1, 2 and 3 together is equivalent to the OrOpt operator on a path. The OrOpt operator is a limited version of 3Opt (breaks 3 arcs on a path).

RELOCATE = 2

Relocate neighborhood with length of 1 (see OROPT comment).

EXCHANGE = 3

Operator which exchanges the positions of two nodes. Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5 (where (1, 5) are first and last nodes of the path and can therefore not be moved): 1 -> [3] -> [2] -> 4 -> 5 1 -> [4] -> 3 -> [2] -> 5 1 -> 2 -> [4] -> [3] -> 5

CROSS = 4

Operator which cross exchanges the starting chains of 2 paths, including exchanging the whole paths. First and last nodes are not moved. Possible neighbors for the paths 1 -> 2 -> 3 -> 4 -> 5 and 6 -> 7 -> 8 (where (1, 5) and (6, 8) are first and last nodes of the paths and can therefore not be moved): 1 -> [7] -> 3 -> 4 -> 5 6 -> [2] -> 8 1 -> [7] -> 4 -> 5 6 -> [2 -> 3] -> 8 1 -> [7] -> 5 6 -> [2 -> 3 -> 4] -> 8

MAKEACTIVE = 5

Operator which inserts an inactive node into a path. Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive (where 1 and 4 are first and last nodes of the path) are: 1 -> [5] -> 2 -> 3 -> 4 1 -> 2 -> [5] -> 3 -> 4 1 -> 2 -> 3 -> [5] -> 4

MAKEINACTIVE = 6

Operator which makes path nodes inactive. Possible neighbors for the path 1 -> 2 -> 3 -> 4 (where 1 and 4 are first and last nodes of the path) are: 1 -> 3 -> 4 with 2 inactive 1 -> 2 -> 4 with 3 inactive

MAKECHAININACTIVE = 7

Operator which makes a "chain" of path nodes inactive. Possible neighbors for the path 1 -> 2 -> 3 -> 4 (where 1 and 4 are first and last nodes of the path) are: 1 -> 3 -> 4 with 2 inactive 1 -> 2 -> 4 with 3 inactive 1 -> 4 with 2 and 3 inactive

SWAPACTIVE = 8

Operator which replaces an active node by an inactive one. Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive (where 1 and 4 are first and last nodes of the path) are: 1 -> [5] -> 3 -> 4 with 2 inactive 1 -> 2 -> [5] -> 4 with 3 inactive

EXTENDEDSWAPACTIVE = 9

Operator which makes an inactive node active and an active one inactive. It is similar to SwapActiveOperator except that it tries to insert the inactive node in all possible positions instead of just the position of the node made inactive. Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive (where 1 and 4 are first and last nodes of the path) are: 1 -> [5] -> 3 -> 4 with 2 inactive 1 -> 3 -> [5] -> 4 with 2 inactive 1 -> [5] -> 2 -> 4 with 3 inactive 1 -> 2 -> [5] -> 4 with 3 inactive

PATHLNS = 10

Operator which relaxes two sub-chains of three consecutive arcs each. Each sub-chain is defined by a start node and the next three arcs. Those six arcs are relaxed to build a new neighbor. PATHLNS explores all possible pairs of starting nodes and so defines n^2 neighbors, n being the number of nodes. Note that the two sub-chains can be part of the same path; they even may overlap.

FULLPATHLNS = 11

Operator which relaxes one entire path and all inactive nodes, thus defining num_paths neighbors.

UNACTIVELNS = 12

Operator which relaxes all inactive nodes and one sub-chain of six consecutive arcs. That way the path can be improved by inserting inactive nodes or swapping arcs.

INCREMENT = 13

Operator which defines one neighbor per variable. Each neighbor tries to increment by one the value of the corresponding variable. When a new solution is found the neighborhood is rebuilt from scratch, i.e., tries to increment values in the variable order. Consider for instance variables x and y. x is incremented one by one to its max, and when it is not possible to increment x anymore, y is incremented once. If this is a solution, then next neighbor tries to increment x.

DECREMENT = 14

Operator which defines a neighborhood to decrement values. The behavior is the same as INCREMENT, except values are decremented instead of incremented.

SIMPLELNS = 15

Operator which defines one neighbor per variable. Each neighbor relaxes one variable. When a new solution is found the neighborhood is rebuilt from scratch. Consider for instance variables x and y. First x is relaxed and the solver is looking for the best possible solution (with only x relaxed). Then y is relaxed, and the solver is looking for a new solution. If a new solution is found, then the next variable to be relaxed is x.

GE = 0

Move is accepted when the current objective value >= objective.Min.

LE = 1

Move is accepted when the current objective value <= objective.Max.

EQ = 2

Move is accepted when the current objective value is in the interval objective.Min .. objective.Max.

DELAYED_PRIORITY = 0

DELAYED_PRIORITY is the lowest priority: Demons will be processed after VAR_PRIORITY and NORMAL_PRIORITY demons.

VAR_PRIORITY = 1

VAR_PRIORITY is between DELAYED_PRIORITY and NORMAL_PRIORITY.

NORMAL_PRIORITY = 2

NORMAL_PRIORITY is the highest priority: Demons will be processed first.

def Parameters(self):
445    def Parameters(self):
446        r""" Stored Parameters."""
447        return _pywrapcp.Solver_Parameters(self)

Stored Parameters.

@staticmethod
def DefaultSolverParameters():
449    @staticmethod
450    def DefaultSolverParameters():
451        r""" Create a ConstraintSolverParameters proto with all the default values."""
452        return _pywrapcp.Solver_DefaultSolverParameters()

Create a ConstraintSolverParameters proto with all the default values.

def AddConstraint(self, c):
454    def AddConstraint(self, c):
455        r"""
456        Adds the constraint 'c' to the model.
457
458        After calling this method, and until there is a backtrack that undoes the
459        addition, any assignment of variables to values must satisfy the given
460        constraint in order to be considered feasible. There are two fairly
461        different use cases:
462
463        - the most common use case is modeling: the given constraint is really
464        part of the problem that the user is trying to solve. In this use case,
465        AddConstraint is called outside of search (i.e., with state() ==
466        OUTSIDE_SEARCH). Most users should only use AddConstraint in this
467        way. In this case, the constraint will belong to the model forever: it
468        cannot be removed by backtracking.
469
470        - a rarer use case is that 'c' is not a real constraint of the model. It
471        may be a constraint generated by a branching decision (a constraint whose
472        goal is to restrict the search space), a symmetry breaking constraint (a
473        constraint that does restrict the search space, but in a way that cannot
474        have an impact on the quality of the solutions in the subtree), or an
475        inferred constraint that, while having no semantic value to the model (it
476        does not restrict the set of solutions), is worth having because we
477        believe it may strengthen the propagation. In these cases, it happens
478        that the constraint is added during the search (i.e., with state() ==
479        IN_SEARCH or state() == IN_ROOT_NODE). When a constraint is
480        added during a search, it applies only to the subtree of the search tree
481        rooted at the current node, and will be automatically removed by
482        backtracking.
483
484        This method does not take ownership of the constraint. If the constraint
485        has been created by any factory method (Solver::MakeXXX), it will
486        automatically be deleted. However, power users who implement their own
487        constraints should do: solver.AddConstraint(solver.RevAlloc(new
488        MyConstraint(...));
489        """
490        return _pywrapcp.Solver_AddConstraint(self, c)

Adds the constraint 'c' to the model.

After calling this method, and until there is a backtrack that undoes the addition, any assignment of variables to values must satisfy the given constraint in order to be considered feasible. There are two fairly different use cases:

  • the most common use case is modeling: the given constraint is really part of the problem that the user is trying to solve. In this use case, AddConstraint is called outside of search (i.e., with state() == OUTSIDE_SEARCH). Most users should only use AddConstraint in this way. In this case, the constraint will belong to the model forever: it cannot be removed by backtracking.

  • a rarer use case is that 'c' is not a real constraint of the model. It may be a constraint generated by a branching decision (a constraint whose goal is to restrict the search space), a symmetry breaking constraint (a constraint that does restrict the search space, but in a way that cannot have an impact on the quality of the solutions in the subtree), or an inferred constraint that, while having no semantic value to the model (it does not restrict the set of solutions), is worth having because we believe it may strengthen the propagation. In these cases, it happens that the constraint is added during the search (i.e., with state() == IN_SEARCH or state() == IN_ROOT_NODE). When a constraint is added during a search, it applies only to the subtree of the search tree rooted at the current node, and will be automatically removed by backtracking.

This method does not take ownership of the constraint. If the constraint has been created by any factory method (Solver::MakeXXX), it will automatically be deleted. However, power users who implement their own constraints should do: solver.AddConstraint(solver.RevAlloc(new MyConstraint(...));

def Solve(self, *args):
492    def Solve(self, *args):
493        return _pywrapcp.Solver_Solve(self, *args)
def NewSearch(self, *args):
495    def NewSearch(self, *args):
496        return _pywrapcp.Solver_NewSearch(self, *args)
def NextSolution(self):
498    def NextSolution(self):
499        return _pywrapcp.Solver_NextSolution(self)
def RestartSearch(self):
501    def RestartSearch(self):
502        return _pywrapcp.Solver_RestartSearch(self)
def EndSearch(self):
504    def EndSearch(self):
505        return _pywrapcp.Solver_EndSearch(self)
def SolveAndCommit(self, *args):
507    def SolveAndCommit(self, *args):
508        return _pywrapcp.Solver_SolveAndCommit(self, *args)
def CheckAssignment(self, solution):
510    def CheckAssignment(self, solution):
511        r""" Checks whether the given assignment satisfies all relevant constraints."""
512        return _pywrapcp.Solver_CheckAssignment(self, solution)

Checks whether the given assignment satisfies all relevant constraints.

def CheckConstraint(self, ct):
514    def CheckConstraint(self, ct):
515        r"""
516        Checks whether adding this constraint will lead to an immediate
517        failure. It will return false if the model is already inconsistent, or if
518        adding the constraint makes it inconsistent.
519        """
520        return _pywrapcp.Solver_CheckConstraint(self, ct)

Checks whether adding this constraint will lead to an immediate failure. It will return false if the model is already inconsistent, or if adding the constraint makes it inconsistent.

def Fail(self):
522    def Fail(self):
523        r""" Abandon the current branch in the search tree. A backtrack will follow."""
524        return _pywrapcp.Solver_Fail(self)

Abandon the current branch in the search tree. A backtrack will follow.

@staticmethod
def MemoryUsage():
526    @staticmethod
527    def MemoryUsage():
528        r""" Current memory usage in bytes"""
529        return _pywrapcp.Solver_MemoryUsage()

Current memory usage in bytes

def WallTime(self):
531    def WallTime(self):
532        r"""
533        DEPRECATED: Use Now() instead.
534        Time elapsed, in ms since the creation of the solver.
535        """
536        return _pywrapcp.Solver_WallTime(self)

DEPRECATED: Use Now() instead. Time elapsed, in ms since the creation of the solver.

def Branches(self):
538    def Branches(self):
539        r""" The number of branches explored since the creation of the solver."""
540        return _pywrapcp.Solver_Branches(self)

The number of branches explored since the creation of the solver.

def Solutions(self):
542    def Solutions(self):
543        r""" The number of solutions found since the start of the search."""
544        return _pywrapcp.Solver_Solutions(self)

The number of solutions found since the start of the search.

def Failures(self):
546    def Failures(self):
547        r""" The number of failures encountered since the creation of the solver."""
548        return _pywrapcp.Solver_Failures(self)

The number of failures encountered since the creation of the solver.

def AcceptedNeighbors(self):
550    def AcceptedNeighbors(self):
551        r""" The number of accepted neighbors."""
552        return _pywrapcp.Solver_AcceptedNeighbors(self)

The number of accepted neighbors.

def Stamp(self):
554    def Stamp(self):
555        r"""
556        The stamp indicates how many moves in the search tree we have performed.
557        It is useful to detect if we need to update same lazy structures.
558        """
559        return _pywrapcp.Solver_Stamp(self)

The stamp indicates how many moves in the search tree we have performed. It is useful to detect if we need to update same lazy structures.

def FailStamp(self):
561    def FailStamp(self):
562        r""" The fail_stamp() is incremented after each backtrack."""
563        return _pywrapcp.Solver_FailStamp(self)

The fail_stamp() is incremented after each backtrack.

def IntVar(self, *args):
565    def IntVar(self, *args):
566        r"""
567        *Overload 1:*
568        MakeIntVar will create the best range based int var for the bounds given.
569
570        |
571
572        *Overload 2:*
573        MakeIntVar will create a variable with the given sparse domain.
574
575        |
576
577        *Overload 3:*
578        MakeIntVar will create a variable with the given sparse domain.
579
580        |
581
582        *Overload 4:*
583        MakeIntVar will create the best range based int var for the bounds given.
584
585        |
586
587        *Overload 5:*
588        MakeIntVar will create a variable with the given sparse domain.
589
590        |
591
592        *Overload 6:*
593        MakeIntVar will create a variable with the given sparse domain.
594        """
595        return _pywrapcp.Solver_IntVar(self, *args)

Overload 1: MakeIntVar will create the best range based int var for the bounds given.

|

Overload 2: MakeIntVar will create a variable with the given sparse domain.

|

Overload 3: MakeIntVar will create a variable with the given sparse domain.

|

Overload 4: MakeIntVar will create the best range based int var for the bounds given.

|

Overload 5: MakeIntVar will create a variable with the given sparse domain.

|

Overload 6: MakeIntVar will create a variable with the given sparse domain.

def BoolVar(self, *args):
597    def BoolVar(self, *args):
598        r"""
599        *Overload 1:*
600        MakeBoolVar will create a variable with a {0, 1} domain.
601
602        |
603
604        *Overload 2:*
605        MakeBoolVar will create a variable with a {0, 1} domain.
606        """
607        return _pywrapcp.Solver_BoolVar(self, *args)

Overload 1: MakeBoolVar will create a variable with a {0, 1} domain.

|

Overload 2: MakeBoolVar will create a variable with a {0, 1} domain.

def IntConst(self, *args):
609    def IntConst(self, *args):
610        r"""
611        *Overload 1:*
612        IntConst will create a constant expression.
613
614        |
615
616        *Overload 2:*
617        IntConst will create a constant expression.
618        """
619        return _pywrapcp.Solver_IntConst(self, *args)

Overload 1: IntConst will create a constant expression.

|

Overload 2: IntConst will create a constant expression.

def Sum(self, vars):
621    def Sum(self, vars):
622        r""" sum of all vars."""
623        return _pywrapcp.Solver_Sum(self, vars)

sum of all vars.

def ScalProd(self, *args):
625    def ScalProd(self, *args):
626        r"""
627        *Overload 1:*
628        scalar product
629
630        |
631
632        *Overload 2:*
633        scalar product
634        """
635        return _pywrapcp.Solver_ScalProd(self, *args)

Overload 1: scalar product

|

Overload 2: scalar product

def MonotonicElement(self, values, increasing, index):
637    def MonotonicElement(self, values, increasing, index):
638        r"""
639        Function based element. The constraint takes ownership of the
640        callback.  The callback must be monotonic. It must be able to
641        cope with any possible value in the domain of 'index'
642        (potentially negative ones too). Furtermore, monotonicity is not
643        checked. Thus giving a non-monotonic function, or specifying an
644        incorrect increasing parameter will result in undefined behavior.
645        """
646        return _pywrapcp.Solver_MonotonicElement(self, values, increasing, index)

Function based element. The constraint takes ownership of the callback. The callback must be monotonic. It must be able to cope with any possible value in the domain of 'index' (potentially negative ones too). Furtermore, monotonicity is not checked. Thus giving a non-monotonic function, or specifying an incorrect increasing parameter will result in undefined behavior.

def Element(self, *args):
648    def Element(self, *args):
649        r"""
650        *Overload 1:*
651        values[index]
652
653        |
654
655        *Overload 2:*
656        values[index]
657
658        |
659
660        *Overload 3:*
661        Function-based element. The constraint takes ownership of the
662        callback. The callback must be able to cope with any possible
663        value in the domain of 'index' (potentially negative ones too).
664
665        |
666
667        *Overload 4:*
668        2D version of function-based element expression, values(expr1, expr2).
669
670        |
671
672        *Overload 5:*
673        vars[expr]
674        """
675        return _pywrapcp.Solver_Element(self, *args)

Overload 1: values[index]

|

Overload 2: values[index]

|

Overload 3: Function-based element. The constraint takes ownership of the callback. The callback must be able to cope with any possible value in the domain of 'index' (potentially negative ones too).

|

Overload 4: 2D version of function-based element expression, values(expr1, expr2).

|

Overload 5: vars[expr]

def IndexExpression(self, vars, value):
677    def IndexExpression(self, vars, value):
678        r"""
679        Returns the expression expr such that vars[expr] == value.
680        It assumes that vars are all different.
681        """
682        return _pywrapcp.Solver_IndexExpression(self, vars, value)

Returns the expression expr such that vars[expr] == value. It assumes that vars are all different.

def Min(self, *args):
684    def Min(self, *args):
685        r"""
686        *Overload 1:*
687        std::min(vars)
688
689        |
690
691        *Overload 2:*
692        std::min (left, right)
693
694        |
695
696        *Overload 3:*
697        std::min(expr, value)
698
699        |
700
701        *Overload 4:*
702        std::min(expr, value)
703        """
704        return _pywrapcp.Solver_Min(self, *args)

Overload 1: std::min(vars)

|

Overload 2: std::min (left, right)

|

Overload 3: std::min(expr, value)

|

Overload 4: std::min(expr, value)

def Max(self, *args):
706    def Max(self, *args):
707        r"""
708        *Overload 1:*
709        std::max(vars)
710
711        |
712
713        *Overload 2:*
714        std::max(left, right)
715
716        |
717
718        *Overload 3:*
719        std::max(expr, value)
720
721        |
722
723        *Overload 4:*
724        std::max(expr, value)
725        """
726        return _pywrapcp.Solver_Max(self, *args)

Overload 1: std::max(vars)

|

Overload 2: std::max(left, right)

|

Overload 3: std::max(expr, value)

|

Overload 4: std::max(expr, value)

def ConvexPiecewiseExpr(self, expr, early_cost, early_date, late_date, late_cost):
728    def ConvexPiecewiseExpr(self, expr, early_cost, early_date, late_date, late_cost):
729        r""" Convex piecewise function."""
730        return _pywrapcp.Solver_ConvexPiecewiseExpr(self, expr, early_cost, early_date, late_date, late_cost)

Convex piecewise function.

def SemiContinuousExpr(self, expr, fixed_charge, step):
732    def SemiContinuousExpr(self, expr, fixed_charge, step):
733        r"""
734        Semi continuous Expression (x <= 0 -> f(x) = 0; x > 0 -> f(x) = ax + b)
735        a >= 0 and b >= 0
736        """
737        return _pywrapcp.Solver_SemiContinuousExpr(self, expr, fixed_charge, step)

Semi continuous Expression (x <= 0 -> f(x) = 0; x > 0 -> f(x) = ax + b) a >= 0 and b >= 0

def ConditionalExpression(self, condition, expr, unperformed_value):
739    def ConditionalExpression(self, condition, expr, unperformed_value):
740        r""" Conditional Expr condition ? expr : unperformed_value"""
741        return _pywrapcp.Solver_ConditionalExpression(self, condition, expr, unperformed_value)

Conditional Expr condition ? expr : unperformed_value

def TrueConstraint(self):
743    def TrueConstraint(self):
744        r""" This constraint always succeeds."""
745        return _pywrapcp.Solver_TrueConstraint(self)

This constraint always succeeds.

def FalseConstraint(self, *args):
747    def FalseConstraint(self, *args):
748        return _pywrapcp.Solver_FalseConstraint(self, *args)
def IsEqualCstCt(self, var, value, boolvar):
750    def IsEqualCstCt(self, var, value, boolvar):
751        r""" boolvar == (var == value)"""
752        return _pywrapcp.Solver_IsEqualCstCt(self, var, value, boolvar)

boolvar == (var == value)

def IsEqualCstVar(self, var, value):
754    def IsEqualCstVar(self, var, value):
755        r""" status var of (var == value)"""
756        return _pywrapcp.Solver_IsEqualCstVar(self, var, value)

status var of (var == value)

def IsEqualCt(self, v1, v2, b):
758    def IsEqualCt(self, v1, v2, b):
759        r""" b == (v1 == v2)"""
760        return _pywrapcp.Solver_IsEqualCt(self, v1, v2, b)

b == (v1 == v2)

def IsEqualVar(self, v1, v2):
762    def IsEqualVar(self, v1, v2):
763        r""" status var of (v1 == v2)"""
764        return _pywrapcp.Solver_IsEqualVar(self, v1, v2)

status var of (v1 == v2)

def IsDifferentCstCt(self, var, value, boolvar):
766    def IsDifferentCstCt(self, var, value, boolvar):
767        r""" boolvar == (var != value)"""
768        return _pywrapcp.Solver_IsDifferentCstCt(self, var, value, boolvar)

boolvar == (var != value)

def IsDifferentCstVar(self, var, value):
770    def IsDifferentCstVar(self, var, value):
771        r""" status var of (var != value)"""
772        return _pywrapcp.Solver_IsDifferentCstVar(self, var, value)

status var of (var != value)

def IsDifferentVar(self, v1, v2):
774    def IsDifferentVar(self, v1, v2):
775        r""" status var of (v1 != v2)"""
776        return _pywrapcp.Solver_IsDifferentVar(self, v1, v2)

status var of (v1 != v2)

def IsDifferentCt(self, v1, v2, b):
778    def IsDifferentCt(self, v1, v2, b):
779        r""" b == (v1 != v2)"""
780        return _pywrapcp.Solver_IsDifferentCt(self, v1, v2, b)

b == (v1 != v2)

def IsLessOrEqualCstCt(self, var, value, boolvar):
782    def IsLessOrEqualCstCt(self, var, value, boolvar):
783        r""" boolvar == (var <= value)"""
784        return _pywrapcp.Solver_IsLessOrEqualCstCt(self, var, value, boolvar)

boolvar == (var <= value)

def IsLessOrEqualCstVar(self, var, value):
786    def IsLessOrEqualCstVar(self, var, value):
787        r""" status var of (var <= value)"""
788        return _pywrapcp.Solver_IsLessOrEqualCstVar(self, var, value)

status var of (var <= value)

def IsLessOrEqualVar(self, left, right):
790    def IsLessOrEqualVar(self, left, right):
791        r""" status var of (left <= right)"""
792        return _pywrapcp.Solver_IsLessOrEqualVar(self, left, right)

status var of (left <= right)

def IsLessOrEqualCt(self, left, right, b):
794    def IsLessOrEqualCt(self, left, right, b):
795        r""" b == (left <= right)"""
796        return _pywrapcp.Solver_IsLessOrEqualCt(self, left, right, b)

b == (left <= right)

def IsGreaterOrEqualCstCt(self, var, value, boolvar):
798    def IsGreaterOrEqualCstCt(self, var, value, boolvar):
799        r""" boolvar == (var >= value)"""
800        return _pywrapcp.Solver_IsGreaterOrEqualCstCt(self, var, value, boolvar)

boolvar == (var >= value)

def IsGreaterOrEqualCstVar(self, var, value):
802    def IsGreaterOrEqualCstVar(self, var, value):
803        r""" status var of (var >= value)"""
804        return _pywrapcp.Solver_IsGreaterOrEqualCstVar(self, var, value)

status var of (var >= value)

def IsGreaterOrEqualVar(self, left, right):
806    def IsGreaterOrEqualVar(self, left, right):
807        r""" status var of (left >= right)"""
808        return _pywrapcp.Solver_IsGreaterOrEqualVar(self, left, right)

status var of (left >= right)

def IsGreaterOrEqualCt(self, left, right, b):
810    def IsGreaterOrEqualCt(self, left, right, b):
811        r""" b == (left >= right)"""
812        return _pywrapcp.Solver_IsGreaterOrEqualCt(self, left, right, b)

b == (left >= right)

def IsGreaterCstCt(self, v, c, b):
814    def IsGreaterCstCt(self, v, c, b):
815        r""" b == (v > c)"""
816        return _pywrapcp.Solver_IsGreaterCstCt(self, v, c, b)

b == (v > c)

def IsGreaterCstVar(self, var, value):
818    def IsGreaterCstVar(self, var, value):
819        r""" status var of (var > value)"""
820        return _pywrapcp.Solver_IsGreaterCstVar(self, var, value)

status var of (var > value)

def IsGreaterVar(self, left, right):
822    def IsGreaterVar(self, left, right):
823        r""" status var of (left > right)"""
824        return _pywrapcp.Solver_IsGreaterVar(self, left, right)

status var of (left > right)

def IsGreaterCt(self, left, right, b):
826    def IsGreaterCt(self, left, right, b):
827        r""" b == (left > right)"""
828        return _pywrapcp.Solver_IsGreaterCt(self, left, right, b)

b == (left > right)

def IsLessCstCt(self, v, c, b):
830    def IsLessCstCt(self, v, c, b):
831        r""" b == (v < c)"""
832        return _pywrapcp.Solver_IsLessCstCt(self, v, c, b)

b == (v < c)

def IsLessCstVar(self, var, value):
834    def IsLessCstVar(self, var, value):
835        r""" status var of (var < value)"""
836        return _pywrapcp.Solver_IsLessCstVar(self, var, value)

status var of (var < value)

def IsLessVar(self, left, right):
838    def IsLessVar(self, left, right):
839        r""" status var of (left < right)"""
840        return _pywrapcp.Solver_IsLessVar(self, left, right)

status var of (left < right)

def IsLessCt(self, left, right, b):
842    def IsLessCt(self, left, right, b):
843        r""" b == (left < right)"""
844        return _pywrapcp.Solver_IsLessCt(self, left, right, b)

b == (left < right)

def SumLessOrEqual(self, vars, cst):
846    def SumLessOrEqual(self, vars, cst):
847        r""" Variation on arrays."""
848        return _pywrapcp.Solver_SumLessOrEqual(self, vars, cst)

Variation on arrays.

def SumGreaterOrEqual(self, vars, cst):
850    def SumGreaterOrEqual(self, vars, cst):
851        return _pywrapcp.Solver_SumGreaterOrEqual(self, vars, cst)
def SumEquality(self, *args):
853    def SumEquality(self, *args):
854        return _pywrapcp.Solver_SumEquality(self, *args)
def ScalProdEquality(self, *args):
856    def ScalProdEquality(self, *args):
857        return _pywrapcp.Solver_ScalProdEquality(self, *args)
def ScalProdGreaterOrEqual(self, *args):
859    def ScalProdGreaterOrEqual(self, *args):
860        return _pywrapcp.Solver_ScalProdGreaterOrEqual(self, *args)
def ScalProdLessOrEqual(self, *args):
862    def ScalProdLessOrEqual(self, *args):
863        return _pywrapcp.Solver_ScalProdLessOrEqual(self, *args)
def MinEquality(self, vars, min_var):
865    def MinEquality(self, vars, min_var):
866        return _pywrapcp.Solver_MinEquality(self, vars, min_var)
def MaxEquality(self, vars, max_var):
868    def MaxEquality(self, vars, max_var):
869        return _pywrapcp.Solver_MaxEquality(self, vars, max_var)
def ElementEquality(self, *args):
871    def ElementEquality(self, *args):
872        return _pywrapcp.Solver_ElementEquality(self, *args)
def AbsEquality(self, var, abs_var):
874    def AbsEquality(self, var, abs_var):
875        r""" Creates the constraint abs(var) == abs_var."""
876        return _pywrapcp.Solver_AbsEquality(self, var, abs_var)

Creates the constraint abs(var) == abs_var.

def IndexOfConstraint(self, vars, index, target):
878    def IndexOfConstraint(self, vars, index, target):
879        r"""
880        This constraint is a special case of the element constraint with
881        an array of integer variables, where the variables are all
882        different and the index variable is constrained such that
883        vars[index] == target.
884        """
885        return _pywrapcp.Solver_IndexOfConstraint(self, vars, index, target)

This constraint is a special case of the element constraint with an array of integer variables, where the variables are all different and the index variable is constrained such that vars[index] == target.

def ConstraintInitialPropagateCallback(self, ct):
887    def ConstraintInitialPropagateCallback(self, ct):
888        r"""
889        This method is a specialized case of the MakeConstraintDemon
890        method to call the InitiatePropagate of the constraint 'ct'.
891        """
892        return _pywrapcp.Solver_ConstraintInitialPropagateCallback(self, ct)

This method is a specialized case of the MakeConstraintDemon method to call the InitiatePropagate of the constraint 'ct'.

def DelayedConstraintInitialPropagateCallback(self, ct):
894    def DelayedConstraintInitialPropagateCallback(self, ct):
895        r"""
896        This method is a specialized case of the MakeConstraintDemon
897        method to call the InitiatePropagate of the constraint 'ct' with
898        low priority.
899        """
900        return _pywrapcp.Solver_DelayedConstraintInitialPropagateCallback(self, ct)

This method is a specialized case of the MakeConstraintDemon method to call the InitiatePropagate of the constraint 'ct' with low priority.

def ClosureDemon(self, closure):
902    def ClosureDemon(self, closure):
903        r""" Creates a demon from a closure."""
904        return _pywrapcp.Solver_ClosureDemon(self, closure)

Creates a demon from a closure.

def BetweenCt(self, expr, l, u):
906    def BetweenCt(self, expr, l, u):
907        r""" (l <= expr <= u)"""
908        return _pywrapcp.Solver_BetweenCt(self, expr, l, u)

(l <= expr <= u)

def IsBetweenCt(self, expr, l, u, b):
910    def IsBetweenCt(self, expr, l, u, b):
911        r""" b == (l <= expr <= u)"""
912        return _pywrapcp.Solver_IsBetweenCt(self, expr, l, u, b)

b == (l <= expr <= u)

def IsBetweenVar(self, v, l, u):
914    def IsBetweenVar(self, v, l, u):
915        return _pywrapcp.Solver_IsBetweenVar(self, v, l, u)
def MemberCt(self, *args):
917    def MemberCt(self, *args):
918        return _pywrapcp.Solver_MemberCt(self, *args)
def NotMemberCt(self, *args):
920    def NotMemberCt(self, *args):
921        r"""
922        *Overload 1:*
923        expr not in set.
924
925        |
926
927        *Overload 2:*
928        expr should not be in the list of forbidden intervals [start[i]..end[i]].
929
930        |
931
932        *Overload 3:*
933        expr should not be in the list of forbidden intervals [start[i]..end[i]].
934        """
935        return _pywrapcp.Solver_NotMemberCt(self, *args)

Overload 1: expr not in set.

|

Overload 2: expr should not be in the list of forbidden intervals [start[i]..end[i]].

|

Overload 3: expr should not be in the list of forbidden intervals [start[i]..end[i]].

def IsMemberCt(self, *args):
937    def IsMemberCt(self, *args):
938        return _pywrapcp.Solver_IsMemberCt(self, *args)
def IsMemberVar(self, *args):
940    def IsMemberVar(self, *args):
941        return _pywrapcp.Solver_IsMemberVar(self, *args)
def Count(self, *args):
943    def Count(self, *args):
944        r"""
945        *Overload 1:*
946        |{i | vars[i] == value}| == max_count
947
948        |
949
950        *Overload 2:*
951        |{i | vars[i] == value}| == max_count
952        """
953        return _pywrapcp.Solver_Count(self, *args)

Overload 1: |{i | vars[i] == value}| == max_count

|

Overload 2: |{i | vars[i] == value}| == max_count

def Distribute(self, *args):
 955    def Distribute(self, *args):
 956        r"""
 957        *Overload 1:*
 958        Aggregated version of count:  |{i | v[i] == values[j]}| == cards[j]
 959
 960        |
 961
 962        *Overload 2:*
 963        Aggregated version of count:  |{i | v[i] == values[j]}| == cards[j]
 964
 965        |
 966
 967        *Overload 3:*
 968        Aggregated version of count:  |{i | v[i] == j}| == cards[j]
 969
 970        |
 971
 972        *Overload 4:*
 973        Aggregated version of count with bounded cardinalities:
 974        forall j in 0 .. card_size - 1: card_min <= |{i | v[i] == j}| <= card_max
 975
 976        |
 977
 978        *Overload 5:*
 979        Aggregated version of count with bounded cardinalities:
 980        forall j in 0 .. card_size - 1:
 981           card_min[j] <= |{i | v[i] == j}| <= card_max[j]
 982
 983        |
 984
 985        *Overload 6:*
 986        Aggregated version of count with bounded cardinalities:
 987        forall j in 0 .. card_size - 1:
 988           card_min[j] <= |{i | v[i] == j}| <= card_max[j]
 989
 990        |
 991
 992        *Overload 7:*
 993        Aggregated version of count with bounded cardinalities:
 994        forall j in 0 .. card_size - 1:
 995           card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j]
 996
 997        |
 998
 999        *Overload 8:*
1000        Aggregated version of count with bounded cardinalities:
1001        forall j in 0 .. card_size - 1:
1002           card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j]
1003        """
1004        return _pywrapcp.Solver_Distribute(self, *args)

Overload 1: Aggregated version of count: |{i | v[i] == values[j]}| == cards[j]

|

Overload 2: Aggregated version of count: |{i | v[i] == values[j]}| == cards[j]

|

Overload 3: Aggregated version of count: |{i | v[i] == j}| == cards[j]

|

Overload 4: Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min <= |{i | v[i] == j}| <= card_max

|

Overload 5: Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= |{i | v[i] == j}| <= card_max[j]

|

Overload 6: Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= |{i | v[i] == j}| <= card_max[j]

|

Overload 7: Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j]

|

Overload 8: Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j]

def Deviation(self, vars, deviation_var, total_sum):
1006    def Deviation(self, vars, deviation_var, total_sum):
1007        r"""
1008        Deviation constraint:
1009        sum_i |n * vars[i] - total_sum| <= deviation_var and
1010        sum_i vars[i] == total_sum
1011        n = #vars
1012        """
1013        return _pywrapcp.Solver_Deviation(self, vars, deviation_var, total_sum)

Deviation constraint: sum_i |n * vars[i] - total_sum| <= deviation_var and sum_i vars[i] == total_sum n = #vars

def AllDifferent(self, *args):
1015    def AllDifferent(self, *args):
1016        r"""
1017        *Overload 1:*
1018        All variables are pairwise different. This corresponds to the
1019        stronger version of the propagation algorithm.
1020
1021        |
1022
1023        *Overload 2:*
1024        All variables are pairwise different.  If 'stronger_propagation'
1025        is true, stronger, and potentially slower propagation will
1026        occur. This API will be deprecated in the future.
1027        """
1028        return _pywrapcp.Solver_AllDifferent(self, *args)

Overload 1: All variables are pairwise different. This corresponds to the stronger version of the propagation algorithm.

|

Overload 2: All variables are pairwise different. If 'stronger_propagation' is true, stronger, and potentially slower propagation will occur. This API will be deprecated in the future.

def AllDifferentExcept(self, vars, escape_value):
1030    def AllDifferentExcept(self, vars, escape_value):
1031        r"""
1032        All variables are pairwise different, unless they are assigned to
1033        the escape value.
1034        """
1035        return _pywrapcp.Solver_AllDifferentExcept(self, vars, escape_value)

All variables are pairwise different, unless they are assigned to the escape value.

def SortingConstraint(self, vars, sorted):
1037    def SortingConstraint(self, vars, sorted):
1038        r"""
1039        Creates a constraint binding the arrays of variables "vars" and
1040        "sorted_vars": sorted_vars[0] must be equal to the minimum of all
1041        variables in vars, and so on: the value of sorted_vars[i] must be
1042        equal to the i-th value of variables invars.
1043
1044        This constraint propagates in both directions: from "vars" to
1045        "sorted_vars" and vice-versa.
1046
1047        Behind the scenes, this constraint maintains that:
1048          - sorted is always increasing.
1049          - whatever the values of vars, there exists a permutation that
1050            injects its values into the sorted variables.
1051
1052        For more info, please have a look at:
1053          https://mpi-inf.mpg.de/~mehlhorn/ftp/Mehlhorn-Thiel.pdf
1054        """
1055        return _pywrapcp.Solver_SortingConstraint(self, vars, sorted)

Creates a constraint binding the arrays of variables "vars" and "sorted_vars": sorted_vars[0] must be equal to the minimum of all variables in vars, and so on: the value of sorted_vars[i] must be equal to the i-th value of variables invars.

This constraint propagates in both directions: from "vars" to "sorted_vars" and vice-versa.

Behind the scenes, this constraint maintains that:

  • sorted is always increasing.
  • whatever the values of vars, there exists a permutation that injects its values into the sorted variables.

For more info, please have a look at: https://mpi-inf.mpg.de/~mehlhorn/ftp/Mehlhorn-Thiel.pdf

def LexicalLess(self, left, right):
1057    def LexicalLess(self, left, right):
1058        r"""
1059        Creates a constraint that enforces that left is lexicographically less
1060        than right.
1061        """
1062        return _pywrapcp.Solver_LexicalLess(self, left, right)

Creates a constraint that enforces that left is lexicographically less than right.

def LexicalLessOrEqual(self, left, right):
1064    def LexicalLessOrEqual(self, left, right):
1065        r"""
1066        Creates a constraint that enforces that left is lexicographically less
1067        than or equal to right.
1068        """
1069        return _pywrapcp.Solver_LexicalLessOrEqual(self, left, right)

Creates a constraint that enforces that left is lexicographically less than or equal to right.

def InversePermutationConstraint(self, left, right):
1071    def InversePermutationConstraint(self, left, right):
1072        r"""
1073        Creates a constraint that enforces that 'left' and 'right' both
1074        represent permutations of [0..left.size()-1], and that 'right' is
1075        the inverse permutation of 'left', i.e. for all i in
1076        [0..left.size()-1], right[left[i]] = i.
1077        """
1078        return _pywrapcp.Solver_InversePermutationConstraint(self, left, right)

Creates a constraint that enforces that 'left' and 'right' both represent permutations of [0..left.size()-1], and that 'right' is the inverse permutation of 'left', i.e. for all i in [0..left.size()-1], right[left[i]] = i.

def NullIntersect(self, first_vars, second_vars):
1080    def NullIntersect(self, first_vars, second_vars):
1081        r"""
1082        Creates a constraint that states that all variables in the first
1083        vector are different from all variables in the second
1084        group. Thus the set of values in the first vector does not
1085        intersect with the set of values in the second vector.
1086        """
1087        return _pywrapcp.Solver_NullIntersect(self, first_vars, second_vars)

Creates a constraint that states that all variables in the first vector are different from all variables in the second group. Thus the set of values in the first vector does not intersect with the set of values in the second vector.

def NullIntersectExcept(self, first_vars, second_vars, escape_value):
1089    def NullIntersectExcept(self, first_vars, second_vars, escape_value):
1090        r"""
1091        Creates a constraint that states that all variables in the first
1092        vector are different from all variables from the second group,
1093        unless they are assigned to the escape value. Thus the set of
1094        values in the first vector minus the escape value does not
1095        intersect with the set of values in the second vector.
1096        """
1097        return _pywrapcp.Solver_NullIntersectExcept(self, first_vars, second_vars, escape_value)

Creates a constraint that states that all variables in the first vector are different from all variables from the second group, unless they are assigned to the escape value. Thus the set of values in the first vector minus the escape value does not intersect with the set of values in the second vector.

def Circuit(self, nexts):
1099    def Circuit(self, nexts):
1100        r""" Force the "nexts" variable to create a complete Hamiltonian path."""
1101        return _pywrapcp.Solver_Circuit(self, nexts)

Force the "nexts" variable to create a complete Hamiltonian path.

def SubCircuit(self, nexts):
1103    def SubCircuit(self, nexts):
1104        r"""
1105        Force the "nexts" variable to create a complete Hamiltonian path
1106        for those that do not loop upon themselves.
1107        """
1108        return _pywrapcp.Solver_SubCircuit(self, nexts)

Force the "nexts" variable to create a complete Hamiltonian path for those that do not loop upon themselves.

def DelayedPathCumul(self, nexts, active, cumuls, transits):
1110    def DelayedPathCumul(self, nexts, active, cumuls, transits):
1111        r"""
1112        Delayed version of the same constraint: propagation on the nexts variables
1113        is delayed until all constraints have propagated.
1114        """
1115        return _pywrapcp.Solver_DelayedPathCumul(self, nexts, active, cumuls, transits)

Delayed version of the same constraint: propagation on the nexts variables is delayed until all constraints have propagated.

def PathCumul(self, *args):
1117    def PathCumul(self, *args):
1118        r"""
1119        *Overload 1:*
1120        Creates a constraint which accumulates values along a path such that:
1121        cumuls[next[i]] = cumuls[i] + transits[i].
1122        Active variables indicate if the corresponding next variable is active;
1123        this could be useful to model unperformed nodes in a routing problem.
1124
1125        |
1126
1127        *Overload 2:*
1128        Creates a constraint which accumulates values along a path such that:
1129        cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]).
1130        Active variables indicate if the corresponding next variable is active;
1131        this could be useful to model unperformed nodes in a routing problem.
1132        Ownership of transit_evaluator is taken and it must be a repeatable
1133        callback.
1134
1135        |
1136
1137        *Overload 3:*
1138        Creates a constraint which accumulates values along a path such that:
1139        cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]) + slacks[i].
1140        Active variables indicate if the corresponding next variable is active;
1141        this could be useful to model unperformed nodes in a routing problem.
1142        Ownership of transit_evaluator is taken and it must be a repeatable
1143        callback.
1144        """
1145        return _pywrapcp.Solver_PathCumul(self, *args)

Overload 1: Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + transits[i]. Active variables indicate if the corresponding next variable is active; this could be useful to model unperformed nodes in a routing problem.

|

Overload 2: Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]). Active variables indicate if the corresponding next variable is active; this could be useful to model unperformed nodes in a routing problem. Ownership of transit_evaluator is taken and it must be a repeatable callback.

|

Overload 3: Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]) + slacks[i]. Active variables indicate if the corresponding next variable is active; this could be useful to model unperformed nodes in a routing problem. Ownership of transit_evaluator is taken and it must be a repeatable callback.

def AllowedAssignments(self, *args):
1147    def AllowedAssignments(self, *args):
1148        r"""
1149        *Overload 1:*
1150        This method creates a constraint where the graph of the relation
1151        between the variables is given in extension. There are 'arity'
1152        variables involved in the relation and the graph is given by a
1153        integer tuple set.
1154
1155        |
1156
1157        *Overload 2:*
1158        Compatibility layer for Python API.
1159        """
1160        return _pywrapcp.Solver_AllowedAssignments(self, *args)

Overload 1: This method creates a constraint where the graph of the relation between the variables is given in extension. There are 'arity' variables involved in the relation and the graph is given by a integer tuple set.

|

Overload 2: Compatibility layer for Python API.

def TransitionConstraint(self, *args):
1162    def TransitionConstraint(self, *args):
1163        return _pywrapcp.Solver_TransitionConstraint(self, *args)
def NonOverlappingBoxesConstraint(self, *args):
1165    def NonOverlappingBoxesConstraint(self, *args):
1166        return _pywrapcp.Solver_NonOverlappingBoxesConstraint(self, *args)
def Pack(self, vars, number_of_bins):
1168    def Pack(self, vars, number_of_bins):
1169        r"""
1170        This constraint packs all variables onto 'number_of_bins'
1171        variables.  For any given variable, a value of 'number_of_bins'
1172        indicates that the variable is not assigned to any bin.
1173        Dimensions, i.e., cumulative constraints on this packing, can be
1174        added directly from the pack class.
1175        """
1176        return _pywrapcp.Solver_Pack(self, vars, number_of_bins)

This constraint packs all variables onto 'number_of_bins' variables. For any given variable, a value of 'number_of_bins' indicates that the variable is not assigned to any bin. Dimensions, i.e., cumulative constraints on this packing, can be added directly from the pack class.

def FixedDurationIntervalVar(self, *args):
1178    def FixedDurationIntervalVar(self, *args):
1179        r"""
1180        *Overload 1:*
1181        Creates an interval var with a fixed duration. The duration must
1182        be greater than 0. If optional is true, then the interval can be
1183        performed or unperformed. If optional is false, then the interval
1184        is always performed.
1185
1186        |
1187
1188        *Overload 2:*
1189        Creates a performed interval var with a fixed duration. The duration must
1190        be greater than 0.
1191
1192        |
1193
1194        *Overload 3:*
1195        Creates an interval var with a fixed duration, and performed_variable.
1196        The duration must be greater than 0.
1197        """
1198        return _pywrapcp.Solver_FixedDurationIntervalVar(self, *args)

Overload 1: Creates an interval var with a fixed duration. The duration must be greater than 0. If optional is true, then the interval can be performed or unperformed. If optional is false, then the interval is always performed.

|

Overload 2: Creates a performed interval var with a fixed duration. The duration must be greater than 0.

|

Overload 3: Creates an interval var with a fixed duration, and performed_variable. The duration must be greater than 0.

def FixedInterval(self, start, duration, name):
1200    def FixedInterval(self, start, duration, name):
1201        r""" Creates a fixed and performed interval."""
1202        return _pywrapcp.Solver_FixedInterval(self, start, duration, name)

Creates a fixed and performed interval.

def IntervalVar( self, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name):
1204    def IntervalVar(self, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name):
1205        r"""
1206        Creates an interval var by specifying the bounds on start,
1207        duration, and end.
1208        """
1209        return _pywrapcp.Solver_IntervalVar(self, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name)

Creates an interval var by specifying the bounds on start, duration, and end.

def MirrorInterval(self, interval_var):
1211    def MirrorInterval(self, interval_var):
1212        r"""
1213        Creates an interval var that is the mirror image of the given one, that
1214        is, the interval var obtained by reversing the axis.
1215        """
1216        return _pywrapcp.Solver_MirrorInterval(self, interval_var)

Creates an interval var that is the mirror image of the given one, that is, the interval var obtained by reversing the axis.

def FixedDurationStartSyncedOnStartIntervalVar(self, interval_var, duration, offset):
1218    def FixedDurationStartSyncedOnStartIntervalVar(self, interval_var, duration, offset):
1219        r"""
1220        Creates an interval var with a fixed duration whose start is
1221        synchronized with the start of another interval, with a given
1222        offset. The performed status is also in sync with the performed
1223        status of the given interval variable.
1224        """
1225        return _pywrapcp.Solver_FixedDurationStartSyncedOnStartIntervalVar(self, interval_var, duration, offset)

Creates an interval var with a fixed duration whose start is synchronized with the start of another interval, with a given offset. The performed status is also in sync with the performed status of the given interval variable.

def FixedDurationStartSyncedOnEndIntervalVar(self, interval_var, duration, offset):
1227    def FixedDurationStartSyncedOnEndIntervalVar(self, interval_var, duration, offset):
1228        r"""
1229        Creates an interval var with a fixed duration whose start is
1230        synchronized with the end of another interval, with a given
1231        offset. The performed status is also in sync with the performed
1232        status of the given interval variable.
1233        """
1234        return _pywrapcp.Solver_FixedDurationStartSyncedOnEndIntervalVar(self, interval_var, duration, offset)

Creates an interval var with a fixed duration whose start is synchronized with the end of another interval, with a given offset. The performed status is also in sync with the performed status of the given interval variable.

def FixedDurationEndSyncedOnStartIntervalVar(self, interval_var, duration, offset):
1236    def FixedDurationEndSyncedOnStartIntervalVar(self, interval_var, duration, offset):
1237        r"""
1238        Creates an interval var with a fixed duration whose end is
1239        synchronized with the start of another interval, with a given
1240        offset. The performed status is also in sync with the performed
1241        status of the given interval variable.
1242        """
1243        return _pywrapcp.Solver_FixedDurationEndSyncedOnStartIntervalVar(self, interval_var, duration, offset)

Creates an interval var with a fixed duration whose end is synchronized with the start of another interval, with a given offset. The performed status is also in sync with the performed status of the given interval variable.

def FixedDurationEndSyncedOnEndIntervalVar(self, interval_var, duration, offset):
1245    def FixedDurationEndSyncedOnEndIntervalVar(self, interval_var, duration, offset):
1246        r"""
1247        Creates an interval var with a fixed duration whose end is
1248        synchronized with the end of another interval, with a given
1249        offset. The performed status is also in sync with the performed
1250        status of the given interval variable.
1251        """
1252        return _pywrapcp.Solver_FixedDurationEndSyncedOnEndIntervalVar(self, interval_var, duration, offset)

Creates an interval var with a fixed duration whose end is synchronized with the end of another interval, with a given offset. The performed status is also in sync with the performed status of the given interval variable.

def IntervalRelaxedMin(self, interval_var):
1254    def IntervalRelaxedMin(self, interval_var):
1255        r"""
1256         Creates and returns an interval variable that wraps around the given one,
1257         relaxing the min start and end. Relaxing means making unbounded when
1258         optional. If the variable is non-optional, this method returns
1259         interval_var.
1260
1261         More precisely, such an interval variable behaves as follows:
1262        When the underlying must be performed, the returned interval variable
1263             behaves exactly as the underlying;
1264        When the underlying may or may not be performed, the returned interval
1265             variable behaves like the underlying, except that it is unbounded on
1266             the min side;
1267        When the underlying cannot be performed, the returned interval variable
1268             is of duration 0 and must be performed in an interval unbounded on
1269             both sides.
1270
1271         This is very useful to implement propagators that may only modify
1272         the start max or end max.
1273        """
1274        return _pywrapcp.Solver_IntervalRelaxedMin(self, interval_var)

Creates and returns an interval variable that wraps around the given one, relaxing the min start and end. Relaxing means making unbounded when optional. If the variable is non-optional, this method returns interval_var.

More precisely, such an interval variable behaves as follows: When the underlying must be performed, the returned interval variable behaves exactly as the underlying; When the underlying may or may not be performed, the returned interval variable behaves like the underlying, except that it is unbounded on the min side; When the underlying cannot be performed, the returned interval variable is of duration 0 and must be performed in an interval unbounded on both sides.

This is very useful to implement propagators that may only modify the start max or end max.

def IntervalRelaxedMax(self, interval_var):
1276    def IntervalRelaxedMax(self, interval_var):
1277        r"""
1278         Creates and returns an interval variable that wraps around the given one,
1279         relaxing the max start and end. Relaxing means making unbounded when
1280         optional. If the variable is non optional, this method returns
1281         interval_var.
1282
1283         More precisely, such an interval variable behaves as follows:
1284        When the underlying must be performed, the returned interval variable
1285             behaves exactly as the underlying;
1286        When the underlying may or may not be performed, the returned interval
1287             variable behaves like the underlying, except that it is unbounded on
1288             the max side;
1289        When the underlying cannot be performed, the returned interval variable
1290             is of duration 0 and must be performed in an interval unbounded on
1291             both sides.
1292
1293         This is very useful for implementing propagators that may only modify
1294         the start min or end min.
1295        """
1296        return _pywrapcp.Solver_IntervalRelaxedMax(self, interval_var)

Creates and returns an interval variable that wraps around the given one, relaxing the max start and end. Relaxing means making unbounded when optional. If the variable is non optional, this method returns interval_var.

More precisely, such an interval variable behaves as follows: When the underlying must be performed, the returned interval variable behaves exactly as the underlying; When the underlying may or may not be performed, the returned interval variable behaves like the underlying, except that it is unbounded on the max side; When the underlying cannot be performed, the returned interval variable is of duration 0 and must be performed in an interval unbounded on both sides.

This is very useful for implementing propagators that may only modify the start min or end min.

def TemporalDisjunction(self, *args):
1298    def TemporalDisjunction(self, *args):
1299        r"""
1300        *Overload 1:*
1301        This constraint implements a temporal disjunction between two
1302        interval vars t1 and t2. 'alt' indicates which alternative was
1303        chosen (alt == 0 is equivalent to t1 before t2).
1304
1305        |
1306
1307        *Overload 2:*
1308        This constraint implements a temporal disjunction between two
1309        interval vars.
1310        """
1311        return _pywrapcp.Solver_TemporalDisjunction(self, *args)

Overload 1: This constraint implements a temporal disjunction between two interval vars t1 and t2. 'alt' indicates which alternative was chosen (alt == 0 is equivalent to t1 before t2).

|

Overload 2: This constraint implements a temporal disjunction between two interval vars.

def DisjunctiveConstraint(self, intervals, name):
1313    def DisjunctiveConstraint(self, intervals, name):
1314        r"""
1315        This constraint forces all interval vars into an non-overlapping
1316        sequence. Intervals with zero duration can be scheduled anywhere.
1317        """
1318        return _pywrapcp.Solver_DisjunctiveConstraint(self, intervals, name)

This constraint forces all interval vars into an non-overlapping sequence. Intervals with zero duration can be scheduled anywhere.

def Cumulative(self, *args):
1320    def Cumulative(self, *args):
1321        r"""
1322        *Overload 1:*
1323        This constraint forces that, for any integer t, the sum of the demands
1324        corresponding to an interval containing t does not exceed the given
1325        capacity.
1326
1327        Intervals and demands should be vectors of equal size.
1328
1329        Demands should only contain non-negative values. Zero values are
1330        supported, and the corresponding intervals are filtered out, as they
1331        neither impact nor are impacted by this constraint.
1332
1333        |
1334
1335        *Overload 2:*
1336        This constraint forces that, for any integer t, the sum of the demands
1337        corresponding to an interval containing t does not exceed the given
1338        capacity.
1339
1340        Intervals and demands should be vectors of equal size.
1341
1342        Demands should only contain non-negative values. Zero values are
1343        supported, and the corresponding intervals are filtered out, as they
1344        neither impact nor are impacted by this constraint.
1345
1346        |
1347
1348        *Overload 3:*
1349        This constraint forces that, for any integer t, the sum of the demands
1350        corresponding to an interval containing t does not exceed the given
1351        capacity.
1352
1353        Intervals and demands should be vectors of equal size.
1354
1355        Demands should only contain non-negative values. Zero values are
1356        supported, and the corresponding intervals are filtered out, as they
1357        neither impact nor are impacted by this constraint.
1358
1359        |
1360
1361        *Overload 4:*
1362        This constraint enforces that, for any integer t, the sum of the demands
1363        corresponding to an interval containing t does not exceed the given
1364        capacity.
1365
1366        Intervals and demands should be vectors of equal size.
1367
1368        Demands should only contain non-negative values. Zero values are
1369        supported, and the corresponding intervals are filtered out, as they
1370        neither impact nor are impacted by this constraint.
1371
1372        |
1373
1374        *Overload 5:*
1375        This constraint enforces that, for any integer t, the sum of demands
1376        corresponding to an interval containing t does not exceed the given
1377        capacity.
1378
1379        Intervals and demands should be vectors of equal size.
1380
1381        Demands should be positive.
1382
1383        |
1384
1385        *Overload 6:*
1386        This constraint enforces that, for any integer t, the sum of demands
1387        corresponding to an interval containing t does not exceed the given
1388        capacity.
1389
1390        Intervals and demands should be vectors of equal size.
1391
1392        Demands should be positive.
1393        """
1394        return _pywrapcp.Solver_Cumulative(self, *args)

Overload 1: This constraint forces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity.

Intervals and demands should be vectors of equal size.

Demands should only contain non-negative values. Zero values are supported, and the corresponding intervals are filtered out, as they neither impact nor are impacted by this constraint.

|

Overload 2: This constraint forces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity.

Intervals and demands should be vectors of equal size.

Demands should only contain non-negative values. Zero values are supported, and the corresponding intervals are filtered out, as they neither impact nor are impacted by this constraint.

|

Overload 3: This constraint forces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity.

Intervals and demands should be vectors of equal size.

Demands should only contain non-negative values. Zero values are supported, and the corresponding intervals are filtered out, as they neither impact nor are impacted by this constraint.

|

Overload 4: This constraint enforces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity.

Intervals and demands should be vectors of equal size.

Demands should only contain non-negative values. Zero values are supported, and the corresponding intervals are filtered out, as they neither impact nor are impacted by this constraint.

|

Overload 5: This constraint enforces that, for any integer t, the sum of demands corresponding to an interval containing t does not exceed the given capacity.

Intervals and demands should be vectors of equal size.

Demands should be positive.

|

Overload 6: This constraint enforces that, for any integer t, the sum of demands corresponding to an interval containing t does not exceed the given capacity.

Intervals and demands should be vectors of equal size.

Demands should be positive.

def Cover(self, vars, target_var):
1396    def Cover(self, vars, target_var):
1397        r"""
1398        This constraint states that the target_var is the convex hull of
1399        the intervals. If none of the interval variables is performed,
1400        then the target var is unperformed too. Also, if the target
1401        variable is unperformed, then all the intervals variables are
1402        unperformed too.
1403        """
1404        return _pywrapcp.Solver_Cover(self, vars, target_var)

This constraint states that the target_var is the convex hull of the intervals. If none of the interval variables is performed, then the target var is unperformed too. Also, if the target variable is unperformed, then all the intervals variables are unperformed too.

def Assignment(self, *args):
1406    def Assignment(self, *args):
1407        r"""
1408        *Overload 1:*
1409        This method creates an empty assignment.
1410
1411        |
1412
1413        *Overload 2:*
1414        This method creates an assignment which is a copy of 'a'.
1415        """
1416        return _pywrapcp.Solver_Assignment(self, *args)

Overload 1: This method creates an empty assignment.

|

Overload 2: This method creates an assignment which is a copy of 'a'.

def FirstSolutionCollector(self, *args):
1418    def FirstSolutionCollector(self, *args):
1419        r"""
1420        *Overload 1:*
1421        Collect the first solution of the search.
1422
1423        |
1424
1425        *Overload 2:*
1426        Collect the first solution of the search. The variables will need to
1427        be added later.
1428        """
1429        return _pywrapcp.Solver_FirstSolutionCollector(self, *args)

Overload 1: Collect the first solution of the search.

|

Overload 2: Collect the first solution of the search. The variables will need to be added later.

def LastSolutionCollector(self, *args):
1431    def LastSolutionCollector(self, *args):
1432        r"""
1433        *Overload 1:*
1434        Collect the last solution of the search.
1435
1436        |
1437
1438        *Overload 2:*
1439        Collect the last solution of the search. The variables will need to
1440        be added later.
1441        """
1442        return _pywrapcp.Solver_LastSolutionCollector(self, *args)

Overload 1: Collect the last solution of the search.

|

Overload 2: Collect the last solution of the search. The variables will need to be added later.

def BestValueSolutionCollector(self, *args):
1444    def BestValueSolutionCollector(self, *args):
1445        r"""
1446        *Overload 1:*
1447        Collect the solution corresponding to the optimal value of the objective
1448        of 'assignment'; if 'assignment' does not have an objective no solution is
1449        collected. This collector only collects one solution corresponding to the
1450        best objective value (the first one found).
1451
1452        |
1453
1454        *Overload 2:*
1455        Collect the solution corresponding to the optimal value of the
1456        objective of the internal assignment; if this assignment does not have an
1457        objective no solution is collected. This collector only collects one
1458        solution corresponding to the best objective value (the first one found).
1459        The variables and objective(s) will need to be added later.
1460        """
1461        return _pywrapcp.Solver_BestValueSolutionCollector(self, *args)

Overload 1: Collect the solution corresponding to the optimal value of the objective of 'assignment'; if 'assignment' does not have an objective no solution is collected. This collector only collects one solution corresponding to the best objective value (the first one found).

|

Overload 2: Collect the solution corresponding to the optimal value of the objective of the internal assignment; if this assignment does not have an objective no solution is collected. This collector only collects one solution corresponding to the best objective value (the first one found). The variables and objective(s) will need to be added later.

def AllSolutionCollector(self, *args):
1463    def AllSolutionCollector(self, *args):
1464        r"""
1465        *Overload 1:*
1466        Collect all solutions of the search.
1467
1468        |
1469
1470        *Overload 2:*
1471        Collect all solutions of the search. The variables will need to
1472        be added later.
1473        """
1474        return _pywrapcp.Solver_AllSolutionCollector(self, *args)

Overload 1: Collect all solutions of the search.

|

Overload 2: Collect all solutions of the search. The variables will need to be added later.

def Minimize(self, v, step):
1476    def Minimize(self, v, step):
1477        r""" Creates a minimization objective."""
1478        return _pywrapcp.Solver_Minimize(self, v, step)

Creates a minimization objective.

def Maximize(self, v, step):
1480    def Maximize(self, v, step):
1481        r""" Creates a maximization objective."""
1482        return _pywrapcp.Solver_Maximize(self, v, step)

Creates a maximization objective.

def Optimize(self, maximize, v, step):
1484    def Optimize(self, maximize, v, step):
1485        r""" Creates a objective with a given sense (true = maximization)."""
1486        return _pywrapcp.Solver_Optimize(self, maximize, v, step)

Creates a objective with a given sense (true = maximization).

def WeightedMinimize(self, *args):
1488    def WeightedMinimize(self, *args):
1489        r"""
1490        *Overload 1:*
1491        Creates a minimization weighted objective. The actual objective is
1492        scalar_prod(sub_objectives, weights).
1493
1494        |
1495
1496        *Overload 2:*
1497        Creates a minimization weighted objective. The actual objective is
1498        scalar_prod(sub_objectives, weights).
1499        """
1500        return _pywrapcp.Solver_WeightedMinimize(self, *args)

Overload 1: Creates a minimization weighted objective. The actual objective is scalar_prod(sub_objectives, weights).

|

Overload 2: Creates a minimization weighted objective. The actual objective is scalar_prod(sub_objectives, weights).

def WeightedMaximize(self, *args):
1502    def WeightedMaximize(self, *args):
1503        r"""
1504        *Overload 1:*
1505        Creates a maximization weigthed objective.
1506
1507        |
1508
1509        *Overload 2:*
1510        Creates a maximization weigthed objective.
1511        """
1512        return _pywrapcp.Solver_WeightedMaximize(self, *args)

Overload 1: Creates a maximization weigthed objective.

|

Overload 2: Creates a maximization weigthed objective.

def WeightedOptimize(self, *args):
1514    def WeightedOptimize(self, *args):
1515        r"""
1516        *Overload 1:*
1517        Creates a weighted objective with a given sense (true = maximization).
1518
1519        |
1520
1521        *Overload 2:*
1522        Creates a weighted objective with a given sense (true = maximization).
1523        """
1524        return _pywrapcp.Solver_WeightedOptimize(self, *args)

Overload 1: Creates a weighted objective with a given sense (true = maximization).

|

Overload 2: Creates a weighted objective with a given sense (true = maximization).

def TabuSearch( self, maximize, objective, step, vars, keep_tenure, forbid_tenure, tabu_factor):
1526    def TabuSearch(self, maximize, objective, step, vars, keep_tenure, forbid_tenure, tabu_factor):
1527        r"""
1528        MetaHeuristics which try to get the search out of local optima.
1529        Creates a Tabu Search monitor.
1530        In the context of local search the behavior is similar to MakeOptimize(),
1531        creating an objective in a given sense. The behavior differs once a local
1532        optimum is reached: thereafter solutions which degrade the value of the
1533        objective are allowed if they are not "tabu". A solution is "tabu" if it
1534        doesn't respect the following rules:
1535        - improving the best solution found so far
1536        - variables in the "keep" list must keep their value, variables in the
1537        "forbid" list must not take the value they have in the list.
1538        Variables with new values enter the tabu lists after each new solution
1539        found and leave the lists after a given number of iterations (called
1540        tenure). Only the variables passed to the method can enter the lists.
1541        The tabu criterion is softened by the tabu factor which gives the number
1542        of "tabu" violations which is tolerated; a factor of 1 means no violations
1543        allowed; a factor of 0 means all violations are allowed.
1544        """
1545        return _pywrapcp.Solver_TabuSearch(self, maximize, objective, step, vars, keep_tenure, forbid_tenure, tabu_factor)

MetaHeuristics which try to get the search out of local optima. Creates a Tabu Search monitor. In the context of local search the behavior is similar to MakeOptimize(), creating an objective in a given sense. The behavior differs once a local optimum is reached: thereafter solutions which degrade the value of the objective are allowed if they are not "tabu". A solution is "tabu" if it doesn't respect the following rules:

  • improving the best solution found so far
  • variables in the "keep" list must keep their value, variables in the "forbid" list must not take the value they have in the list. Variables with new values enter the tabu lists after each new solution found and leave the lists after a given number of iterations (called tenure). Only the variables passed to the method can enter the lists. The tabu criterion is softened by the tabu factor which gives the number of "tabu" violations which is tolerated; a factor of 1 means no violations allowed; a factor of 0 means all violations are allowed.
def SimulatedAnnealing(self, maximize, v, step, initial_temperature):
1547    def SimulatedAnnealing(self, maximize, v, step, initial_temperature):
1548        r""" Creates a Simulated Annealing monitor."""
1549        return _pywrapcp.Solver_SimulatedAnnealing(self, maximize, v, step, initial_temperature)

Creates a Simulated Annealing monitor.

def LubyRestart(self, scale_factor):
1551    def LubyRestart(self, scale_factor):
1552        r"""
1553        This search monitor will restart the search periodically.
1554        At the iteration n, it will restart after scale_factor * Luby(n) failures
1555        where Luby is the Luby Strategy (i.e. 1 1 2 1 1 2 4 1 1 2 1 1 2 4 8...).
1556        """
1557        return _pywrapcp.Solver_LubyRestart(self, scale_factor)

This search monitor will restart the search periodically. At the iteration n, it will restart after scale_factor * Luby(n) failures where Luby is the Luby Strategy (i.e. 1 1 2 1 1 2 4 1 1 2 1 1 2 4 8...).

def ConstantRestart(self, frequency):
1559    def ConstantRestart(self, frequency):
1560        r"""
1561        This search monitor will restart the search periodically after 'frequency'
1562        failures.
1563        """
1564        return _pywrapcp.Solver_ConstantRestart(self, frequency)

This search monitor will restart the search periodically after 'frequency' failures.

def TimeLimit(self, *args):
1566    def TimeLimit(self, *args):
1567        return _pywrapcp.Solver_TimeLimit(self, *args)
def BranchesLimit(self, branches):
1569    def BranchesLimit(self, branches):
1570        r"""
1571        Creates a search limit that constrains the number of branches
1572        explored in the search tree.
1573        """
1574        return _pywrapcp.Solver_BranchesLimit(self, branches)

Creates a search limit that constrains the number of branches explored in the search tree.

def FailuresLimit(self, failures):
1576    def FailuresLimit(self, failures):
1577        r"""
1578        Creates a search limit that constrains the number of failures
1579        that can happen when exploring the search tree.
1580        """
1581        return _pywrapcp.Solver_FailuresLimit(self, failures)

Creates a search limit that constrains the number of failures that can happen when exploring the search tree.

def SolutionsLimit(self, solutions):
1583    def SolutionsLimit(self, solutions):
1584        r"""
1585        Creates a search limit that constrains the number of solutions found
1586        during the search.
1587        """
1588        return _pywrapcp.Solver_SolutionsLimit(self, solutions)

Creates a search limit that constrains the number of solutions found during the search.

def Limit(self, *args):
1590    def Limit(self, *args):
1591        r"""
1592        *Overload 1:*
1593        Limits the search with the 'time', 'branches', 'failures' and
1594        'solutions' limits. 'smart_time_check' reduces the calls to the wall
1595
1596        |
1597
1598        *Overload 2:*
1599        Creates a search limit from its protobuf description
1600
1601        |
1602
1603        *Overload 3:*
1604        Creates a search limit that is reached when either of the underlying limit
1605        is reached. That is, the returned limit is more stringent than both
1606        argument limits.
1607        """
1608        return _pywrapcp.Solver_Limit(self, *args)

Overload 1: Limits the search with the 'time', 'branches', 'failures' and 'solutions' limits. 'smart_time_check' reduces the calls to the wall

|

Overload 2: Creates a search limit from its protobuf description

|

Overload 3: Creates a search limit that is reached when either of the underlying limit is reached. That is, the returned limit is more stringent than both argument limits.

def CustomLimit(self, limiter):
1610    def CustomLimit(self, limiter):
1611        r"""
1612        Callback-based search limit. Search stops when limiter returns true; if
1613        this happens at a leaf the corresponding solution will be rejected.
1614        """
1615        return _pywrapcp.Solver_CustomLimit(self, limiter)

Callback-based search limit. Search stops when limiter returns true; if this happens at a leaf the corresponding solution will be rejected.

def SearchLog(self, *args):
1617    def SearchLog(self, *args):
1618        return _pywrapcp.Solver_SearchLog(self, *args)
def SearchTrace(self, prefix):
1620    def SearchTrace(self, prefix):
1621        r"""
1622        Creates a search monitor that will trace precisely the behavior of the
1623        search. Use this only for low level debugging.
1624        """
1625        return _pywrapcp.Solver_SearchTrace(self, prefix)

Creates a search monitor that will trace precisely the behavior of the search. Use this only for low level debugging.

def PrintModelVisitor(self):
1627    def PrintModelVisitor(self):
1628        r""" Prints the model."""
1629        return _pywrapcp.Solver_PrintModelVisitor(self)

Prints the model.

def StatisticsModelVisitor(self):
1631    def StatisticsModelVisitor(self):
1632        r""" Displays some nice statistics on the model."""
1633        return _pywrapcp.Solver_StatisticsModelVisitor(self)

Displays some nice statistics on the model.

def AssignVariableValue(self, var, val):
1635    def AssignVariableValue(self, var, val):
1636        r""" Decisions."""
1637        return _pywrapcp.Solver_AssignVariableValue(self, var, val)

Decisions.

def VariableLessOrEqualValue(self, var, value):
1639    def VariableLessOrEqualValue(self, var, value):
1640        return _pywrapcp.Solver_VariableLessOrEqualValue(self, var, value)
def VariableGreaterOrEqualValue(self, var, value):
1642    def VariableGreaterOrEqualValue(self, var, value):
1643        return _pywrapcp.Solver_VariableGreaterOrEqualValue(self, var, value)
def SplitVariableDomain(self, var, val, start_with_lower_half):
1645    def SplitVariableDomain(self, var, val, start_with_lower_half):
1646        return _pywrapcp.Solver_SplitVariableDomain(self, var, val, start_with_lower_half)
def AssignVariableValueOrFail(self, var, value):
1648    def AssignVariableValueOrFail(self, var, value):
1649        return _pywrapcp.Solver_AssignVariableValueOrFail(self, var, value)
def AssignVariablesValues(self, vars, values):
1651    def AssignVariablesValues(self, vars, values):
1652        return _pywrapcp.Solver_AssignVariablesValues(self, vars, values)
def FailDecision(self):
1654    def FailDecision(self):
1655        return _pywrapcp.Solver_FailDecision(self)
def Decision(self, apply, refute):
1657    def Decision(self, apply, refute):
1658        return _pywrapcp.Solver_Decision(self, apply, refute)
def Compose(self, dbs):
1660    def Compose(self, dbs):
1661        return _pywrapcp.Solver_Compose(self, dbs)
def Try(self, dbs):
1663    def Try(self, dbs):
1664        return _pywrapcp.Solver_Try(self, dbs)
def DefaultPhase(self, *args):
1666    def DefaultPhase(self, *args):
1667        return _pywrapcp.Solver_DefaultPhase(self, *args)
def ScheduleOrPostpone(self, var, est, marker):
1669    def ScheduleOrPostpone(self, var, est, marker):
1670        r"""
1671        Returns a decision that tries to schedule a task at a given time.
1672        On the Apply branch, it will set that interval var as performed and set
1673        its start to 'est'. On the Refute branch, it will just update the
1674        'marker' to 'est' + 1. This decision is used in the
1675        INTERVAL_SET_TIMES_FORWARD strategy.
1676        """
1677        return _pywrapcp.Solver_ScheduleOrPostpone(self, var, est, marker)

Returns a decision that tries to schedule a task at a given time. On the Apply branch, it will set that interval var as performed and set its start to 'est'. On the Refute branch, it will just update the 'marker' to 'est' + 1. This decision is used in the INTERVAL_SET_TIMES_FORWARD strategy.

def ScheduleOrExpedite(self, var, est, marker):
1679    def ScheduleOrExpedite(self, var, est, marker):
1680        r"""
1681        Returns a decision that tries to schedule a task at a given time.
1682        On the Apply branch, it will set that interval var as performed and set
1683        its end to 'est'. On the Refute branch, it will just update the
1684        'marker' to 'est' - 1. This decision is used in the
1685        INTERVAL_SET_TIMES_BACKWARD strategy.
1686        """
1687        return _pywrapcp.Solver_ScheduleOrExpedite(self, var, est, marker)

Returns a decision that tries to schedule a task at a given time. On the Apply branch, it will set that interval var as performed and set its end to 'est'. On the Refute branch, it will just update the 'marker' to 'est' - 1. This decision is used in the INTERVAL_SET_TIMES_BACKWARD strategy.

def RankFirstInterval(self, sequence, index):
1689    def RankFirstInterval(self, sequence, index):
1690        r"""
1691        Returns a decision that tries to rank first the ith interval var
1692        in the sequence variable.
1693        """
1694        return _pywrapcp.Solver_RankFirstInterval(self, sequence, index)

Returns a decision that tries to rank first the ith interval var in the sequence variable.

def RankLastInterval(self, sequence, index):
1696    def RankLastInterval(self, sequence, index):
1697        r"""
1698        Returns a decision that tries to rank last the ith interval var
1699        in the sequence variable.
1700        """
1701        return _pywrapcp.Solver_RankLastInterval(self, sequence, index)

Returns a decision that tries to rank last the ith interval var in the sequence variable.

def Phase(self, *args):
1703    def Phase(self, *args):
1704        return _pywrapcp.Solver_Phase(self, *args)
def DecisionBuilderFromAssignment(self, assignment, db, vars):
1706    def DecisionBuilderFromAssignment(self, assignment, db, vars):
1707        r"""
1708        Returns a decision builder for which the left-most leaf corresponds
1709        to assignment, the rest of the tree being explored using 'db'.
1710        """
1711        return _pywrapcp.Solver_DecisionBuilderFromAssignment(self, assignment, db, vars)

Returns a decision builder for which the left-most leaf corresponds to assignment, the rest of the tree being explored using 'db'.

def ConstraintAdder(self, ct):
1713    def ConstraintAdder(self, ct):
1714        r"""
1715        Returns a decision builder that will add the given constraint to
1716        the model.
1717        """
1718        return _pywrapcp.Solver_ConstraintAdder(self, ct)

Returns a decision builder that will add the given constraint to the model.

def SolveOnce(self, db, monitors):
1720    def SolveOnce(self, db, monitors):
1721        return _pywrapcp.Solver_SolveOnce(self, db, monitors)
def NestedOptimize(self, *args):
1723    def NestedOptimize(self, *args):
1724        return _pywrapcp.Solver_NestedOptimize(self, *args)
def RestoreAssignment(self, assignment):
1726    def RestoreAssignment(self, assignment):
1727        r"""
1728        Returns a DecisionBuilder which restores an Assignment
1729        (calls void Assignment::Restore())
1730        """
1731        return _pywrapcp.Solver_RestoreAssignment(self, assignment)

Returns a DecisionBuilder which restores an Assignment (calls void Assignment::Restore())

def StoreAssignment(self, assignment):
1733    def StoreAssignment(self, assignment):
1734        r"""
1735        Returns a DecisionBuilder which stores an Assignment
1736        (calls void Assignment::Store())
1737        """
1738        return _pywrapcp.Solver_StoreAssignment(self, assignment)

Returns a DecisionBuilder which stores an Assignment (calls void Assignment::Store())

def Operator(self, *args):
1740    def Operator(self, *args):
1741        return _pywrapcp.Solver_Operator(self, *args)
def RandomLnsOperator(self, *args):
1743    def RandomLnsOperator(self, *args):
1744        return _pywrapcp.Solver_RandomLnsOperator(self, *args)
def MoveTowardTargetOperator(self, *args):
1746    def MoveTowardTargetOperator(self, *args):
1747        r"""
1748        *Overload 1:*
1749        Creates a local search operator that tries to move the assignment of some
1750        variables toward a target. The target is given as an Assignment. This
1751        operator generates neighbors in which the only difference compared to the
1752        current state is that one variable that belongs to the target assignment
1753        is set to its target value.
1754
1755        |
1756
1757        *Overload 2:*
1758        Creates a local search operator that tries to move the assignment of some
1759        variables toward a target. The target is given either as two vectors: a
1760        vector of variables and a vector of associated target values. The two
1761        vectors should be of the same length. This operator generates neighbors in
1762        which the only difference compared to the current state is that one
1763        variable that belongs to the given vector is set to its target value.
1764        """
1765        return _pywrapcp.Solver_MoveTowardTargetOperator(self, *args)

Overload 1: Creates a local search operator that tries to move the assignment of some variables toward a target. The target is given as an Assignment. This operator generates neighbors in which the only difference compared to the current state is that one variable that belongs to the target assignment is set to its target value.

|

Overload 2: Creates a local search operator that tries to move the assignment of some variables toward a target. The target is given either as two vectors: a vector of variables and a vector of associated target values. The two vectors should be of the same length. This operator generates neighbors in which the only difference compared to the current state is that one variable that belongs to the given vector is set to its target value.

def ConcatenateOperators(self, *args):
1767    def ConcatenateOperators(self, *args):
1768        return _pywrapcp.Solver_ConcatenateOperators(self, *args)
def RandomConcatenateOperators(self, *args):
1770    def RandomConcatenateOperators(self, *args):
1771        r"""
1772        *Overload 1:*
1773        Randomized version of local search concatenator; calls a random operator
1774        at each call to MakeNextNeighbor().
1775
1776        |
1777
1778        *Overload 2:*
1779        Randomized version of local search concatenator; calls a random operator
1780        at each call to MakeNextNeighbor(). The provided seed is used to
1781        initialize the random number generator.
1782        """
1783        return _pywrapcp.Solver_RandomConcatenateOperators(self, *args)

Overload 1: Randomized version of local search concatenator; calls a random operator at each call to MakeNextNeighbor().

|

Overload 2: Randomized version of local search concatenator; calls a random operator at each call to MakeNextNeighbor(). The provided seed is used to initialize the random number generator.

def NeighborhoodLimit(self, op, limit):
1785    def NeighborhoodLimit(self, op, limit):
1786        r"""
1787        Creates a local search operator that wraps another local search
1788        operator and limits the number of neighbors explored (i.e., calls
1789        to MakeNextNeighbor from the current solution (between two calls
1790        to Start()). When this limit is reached, MakeNextNeighbor()
1791        returns false. The counter is cleared when Start() is called.
1792        """
1793        return _pywrapcp.Solver_NeighborhoodLimit(self, op, limit)

Creates a local search operator that wraps another local search operator and limits the number of neighbors explored (i.e., calls to MakeNextNeighbor from the current solution (between two calls to Start()). When this limit is reached, MakeNextNeighbor() returns false. The counter is cleared when Start() is called.

def LocalSearchPhase(self, *args):
1795    def LocalSearchPhase(self, *args):
1796        return _pywrapcp.Solver_LocalSearchPhase(self, *args)
def LocalSearchPhaseParameters(self, *args):
1798    def LocalSearchPhaseParameters(self, *args):
1799        return _pywrapcp.Solver_LocalSearchPhaseParameters(self, *args)
def TopProgressPercent(self):
1801    def TopProgressPercent(self):
1802        r"""
1803        Returns a percentage representing the propress of the search before
1804        reaching the limits of the top-level search (can be called from a nested
1805        solve).
1806        """
1807        return _pywrapcp.Solver_TopProgressPercent(self)

Returns a percentage representing the propress of the search before reaching the limits of the top-level search (can be called from a nested solve).

def SearchDepth(self):
1809    def SearchDepth(self):
1810        r"""
1811        Gets the search depth of the current active search. Returns -1 if
1812        there is no active search opened.
1813        """
1814        return _pywrapcp.Solver_SearchDepth(self)

Gets the search depth of the current active search. Returns -1 if there is no active search opened.

def SearchLeftDepth(self):
1816    def SearchLeftDepth(self):
1817        r"""
1818        Gets the search left depth of the current active search. Returns -1 if
1819        there is no active search opened.
1820        """
1821        return _pywrapcp.Solver_SearchLeftDepth(self)

Gets the search left depth of the current active search. Returns -1 if there is no active search opened.

def SolveDepth(self):
1823    def SolveDepth(self):
1824        r"""
1825        Gets the number of nested searches. It returns 0 outside search,
1826        1 during the top level search, 2 or more in case of nested searches.
1827        """
1828        return _pywrapcp.Solver_SolveDepth(self)

Gets the number of nested searches. It returns 0 outside search, 1 during the top level search, 2 or more in case of nested searches.

def Rand64(self, size):
1830    def Rand64(self, size):
1831        r""" Returns a random value between 0 and 'size' - 1;"""
1832        return _pywrapcp.Solver_Rand64(self, size)

Returns a random value between 0 and 'size' - 1;

def Rand32(self, size):
1834    def Rand32(self, size):
1835        r""" Returns a random value between 0 and 'size' - 1;"""
1836        return _pywrapcp.Solver_Rand32(self, size)

Returns a random value between 0 and 'size' - 1;

def ReSeed(self, seed):
1838    def ReSeed(self, seed):
1839        r""" Reseed the solver random generator."""
1840        return _pywrapcp.Solver_ReSeed(self, seed)

Reseed the solver random generator.

def LocalSearchProfile(self):
1842    def LocalSearchProfile(self):
1843        r""" Returns local search profiling information in a human readable format."""
1844        return _pywrapcp.Solver_LocalSearchProfile(self)

Returns local search profiling information in a human readable format.

def Constraints(self):
1846    def Constraints(self):
1847        r"""
1848        Counts the number of constraints that have been added
1849        to the solver before the search.
1850        """
1851        return _pywrapcp.Solver_Constraints(self)

Counts the number of constraints that have been added to the solver before the search.

def Accept(self, visitor):
1853    def Accept(self, visitor):
1854        r""" Accepts the given model visitor."""
1855        return _pywrapcp.Solver_Accept(self, visitor)

Accepts the given model visitor.

def FinishCurrentSearch(self):
1857    def FinishCurrentSearch(self):
1858        r""" Tells the solver to kill or restart the current search."""
1859        return _pywrapcp.Solver_FinishCurrentSearch(self)

Tells the solver to kill or restart the current search.

def RestartCurrentSearch(self):
1861    def RestartCurrentSearch(self):
1862        return _pywrapcp.Solver_RestartCurrentSearch(self)
def ShouldFail(self):
1864    def ShouldFail(self):
1865        r"""
1866        These methods are only useful for the SWIG wrappers, which need a way
1867        to externally cause the Solver to fail.
1868        """
1869        return _pywrapcp.Solver_ShouldFail(self)

These methods are only useful for the SWIG wrappers, which need a way to externally cause the Solver to fail.

def Add(self, ct):
1874    def Add(self, ct):
1875      if isinstance(ct, PyConstraint):
1876        self.__python_constraints.append(ct)
1877      self.AddConstraint(ct)
def TreeNoCycle(self, nexts, active, callback=0):
1880    def TreeNoCycle(self, nexts, active, callback=0):
1881        return _pywrapcp.Solver_TreeNoCycle(self, nexts, active, callback)
def SearchLogWithCallback(self, period, callback):
1883    def SearchLogWithCallback(self, period, callback):
1884        return _pywrapcp.Solver_SearchLogWithCallback(self, period, callback)
def ElementFunction(self, values, index):
1886    def ElementFunction(self, values, index):
1887        return _pywrapcp.Solver_ElementFunction(self, values, index)
def VarEvalValStrPhase(self, vars, var_evaluator, val_str):
1889    def VarEvalValStrPhase(self, vars, var_evaluator, val_str):
1890        return _pywrapcp.Solver_VarEvalValStrPhase(self, vars, var_evaluator, val_str)
def VarStrValEvalPhase(self, vars, var_str, val_eval):
1892    def VarStrValEvalPhase(self, vars, var_str, val_eval):
1893        return _pywrapcp.Solver_VarStrValEvalPhase(self, vars, var_str, val_eval)
def VarEvalValEvalPhase(self, vars, var_eval, val_eval):
1895    def VarEvalValEvalPhase(self, vars, var_eval, val_eval):
1896        return _pywrapcp.Solver_VarEvalValEvalPhase(self, vars, var_eval, val_eval)
def VarStrValEvalTieBreakPhase(self, vars, var_str, val_eval, tie_breaker):
1898    def VarStrValEvalTieBreakPhase(self, vars, var_str, val_eval, tie_breaker):
1899        return _pywrapcp.Solver_VarStrValEvalTieBreakPhase(self, vars, var_str, val_eval, tie_breaker)
def VarEvalValEvalTieBreakPhase(self, vars, var_eval, val_eval, tie_breaker):
1901    def VarEvalValEvalTieBreakPhase(self, vars, var_eval, val_eval, tie_breaker):
1902        return _pywrapcp.Solver_VarEvalValEvalTieBreakPhase(self, vars, var_eval, val_eval, tie_breaker)
def EvalEvalStrPhase(self, vars, evaluator, str):
1904    def EvalEvalStrPhase(self, vars, evaluator, str):
1905        return _pywrapcp.Solver_EvalEvalStrPhase(self, vars, evaluator, str)
def EvalEvalStrTieBreakPhase(self, vars, evaluator, tie_breaker, str):
1907    def EvalEvalStrTieBreakPhase(self, vars, evaluator, tie_breaker, str):
1908        return _pywrapcp.Solver_EvalEvalStrTieBreakPhase(self, vars, evaluator, tie_breaker, str)
def GuidedLocalSearch(self, *args):
1910    def GuidedLocalSearch(self, *args):
1911        return _pywrapcp.Solver_GuidedLocalSearch(self, *args)
def SumObjectiveFilter(self, vars, values, filter_enum):
1913    def SumObjectiveFilter(self, vars, values, filter_enum):
1914        return _pywrapcp.Solver_SumObjectiveFilter(self, vars, values, filter_enum)
class BaseObject:
1918class BaseObject(object):
1919    r"""
1920    A BaseObject is the root of all reversibly allocated objects.
1921    A DebugString method and the associated << operator are implemented
1922    as a convenience.
1923    """
1924
1925    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1926
1927    def __init__(self):
1928        if self.__class__ == BaseObject:
1929            _self = None
1930        else:
1931            _self = self
1932        _pywrapcp.BaseObject_swiginit(self, _pywrapcp.new_BaseObject(_self, ))
1933    __swig_destroy__ = _pywrapcp.delete_BaseObject
1934
1935    def DebugString(self):
1936        return _pywrapcp.BaseObject_DebugString(self)
1937
1938    def __str__(self):
1939        return _pywrapcp.BaseObject___str__(self)
1940
1941    def __repr__(self):
1942        return _pywrapcp.BaseObject___repr__(self)
1943    def __disown__(self):
1944        self.this.disown()
1945        _pywrapcp.disown_BaseObject(self)
1946        return weakref.proxy(self)

A BaseObject is the root of all reversibly allocated objects. A DebugString method and the associated << operator are implemented as a convenience.

thisown

The membership flag

def DebugString(self):
1935    def DebugString(self):
1936        return _pywrapcp.BaseObject_DebugString(self)
class PropagationBaseObject(BaseObject):
1950class PropagationBaseObject(BaseObject):
1951    r"""
1952    NOLINT
1953    The PropagationBaseObject is a subclass of BaseObject that is also
1954    friend to the Solver class. It allows accessing methods useful when
1955    writing new constraints or new expressions.
1956    """
1957
1958    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1959    __repr__ = _swig_repr
1960
1961    def __init__(self, s):
1962        if self.__class__ == PropagationBaseObject:
1963            _self = None
1964        else:
1965            _self = self
1966        _pywrapcp.PropagationBaseObject_swiginit(self, _pywrapcp.new_PropagationBaseObject(_self, s))
1967    __swig_destroy__ = _pywrapcp.delete_PropagationBaseObject
1968
1969    def DebugString(self):
1970        return _pywrapcp.PropagationBaseObject_DebugString(self)
1971
1972    def solver(self):
1973        return _pywrapcp.PropagationBaseObject_solver(self)
1974
1975    def Name(self):
1976        r""" Object naming."""
1977        return _pywrapcp.PropagationBaseObject_Name(self)
1978    def __disown__(self):
1979        self.this.disown()
1980        _pywrapcp.disown_PropagationBaseObject(self)
1981        return weakref.proxy(self)

NOLINT The PropagationBaseObject is a subclass of BaseObject that is also friend to the Solver class. It allows accessing methods useful when writing new constraints or new expressions.

PropagationBaseObject(s)
1961    def __init__(self, s):
1962        if self.__class__ == PropagationBaseObject:
1963            _self = None
1964        else:
1965            _self = self
1966        _pywrapcp.PropagationBaseObject_swiginit(self, _pywrapcp.new_PropagationBaseObject(_self, s))
thisown

The membership flag

def DebugString(self):
1969    def DebugString(self):
1970        return _pywrapcp.PropagationBaseObject_DebugString(self)
def solver(self):
1972    def solver(self):
1973        return _pywrapcp.PropagationBaseObject_solver(self)
def Name(self):
1975    def Name(self):
1976        r""" Object naming."""
1977        return _pywrapcp.PropagationBaseObject_Name(self)

Object naming.

class Decision(BaseObject):
1985class Decision(BaseObject):
1986    r"""
1987    A Decision represents a choice point in the search tree. The two main
1988    methods are Apply() to go left, or Refute() to go right.
1989    """
1990
1991    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1992
1993    def __init__(self):
1994        if self.__class__ == Decision:
1995            _self = None
1996        else:
1997            _self = self
1998        _pywrapcp.Decision_swiginit(self, _pywrapcp.new_Decision(_self, ))
1999    __swig_destroy__ = _pywrapcp.delete_Decision
2000
2001    def ApplyWrapper(self, s):
2002        r""" Apply will be called first when the decision is executed."""
2003        return _pywrapcp.Decision_ApplyWrapper(self, s)
2004
2005    def RefuteWrapper(self, s):
2006        r""" Refute will be called after a backtrack."""
2007        return _pywrapcp.Decision_RefuteWrapper(self, s)
2008
2009    def DebugString(self):
2010        return _pywrapcp.Decision_DebugString(self)
2011
2012    def __repr__(self):
2013        return _pywrapcp.Decision___repr__(self)
2014
2015    def __str__(self):
2016        return _pywrapcp.Decision___str__(self)
2017    def __disown__(self):
2018        self.this.disown()
2019        _pywrapcp.disown_Decision(self)
2020        return weakref.proxy(self)

A Decision represents a choice point in the search tree. The two main methods are Apply() to go left, or Refute() to go right.

thisown

The membership flag

def ApplyWrapper(self, s):
2001    def ApplyWrapper(self, s):
2002        r""" Apply will be called first when the decision is executed."""
2003        return _pywrapcp.Decision_ApplyWrapper(self, s)

Apply will be called first when the decision is executed.

def RefuteWrapper(self, s):
2005    def RefuteWrapper(self, s):
2006        r""" Refute will be called after a backtrack."""
2007        return _pywrapcp.Decision_RefuteWrapper(self, s)

Refute will be called after a backtrack.

def DebugString(self):
2009    def DebugString(self):
2010        return _pywrapcp.Decision_DebugString(self)
class DecisionBuilder(BaseObject):
2024class DecisionBuilder(BaseObject):
2025    r"""
2026    A DecisionBuilder is responsible for creating the search tree. The
2027    important method is Next(), which returns the next decision to execute.
2028    """
2029
2030    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2031
2032    def __init__(self):
2033        if self.__class__ == DecisionBuilder:
2034            _self = None
2035        else:
2036            _self = self
2037        _pywrapcp.DecisionBuilder_swiginit(self, _pywrapcp.new_DecisionBuilder(_self, ))
2038    __swig_destroy__ = _pywrapcp.delete_DecisionBuilder
2039
2040    def NextWrapper(self, s):
2041        r"""
2042        This is the main method of the decision builder class. It must
2043        return a decision (an instance of the class Decision). If it
2044        returns nullptr, this means that the decision builder has finished
2045        its work.
2046        """
2047        return _pywrapcp.DecisionBuilder_NextWrapper(self, s)
2048
2049    def DebugString(self):
2050        return _pywrapcp.DecisionBuilder_DebugString(self)
2051
2052    def __repr__(self):
2053        return _pywrapcp.DecisionBuilder___repr__(self)
2054
2055    def __str__(self):
2056        return _pywrapcp.DecisionBuilder___str__(self)
2057    def __disown__(self):
2058        self.this.disown()
2059        _pywrapcp.disown_DecisionBuilder(self)
2060        return weakref.proxy(self)

A DecisionBuilder is responsible for creating the search tree. The important method is Next(), which returns the next decision to execute.

thisown

The membership flag

def NextWrapper(self, s):
2040    def NextWrapper(self, s):
2041        r"""
2042        This is the main method of the decision builder class. It must
2043        return a decision (an instance of the class Decision). If it
2044        returns nullptr, this means that the decision builder has finished
2045        its work.
2046        """
2047        return _pywrapcp.DecisionBuilder_NextWrapper(self, s)

This is the main method of the decision builder class. It must return a decision (an instance of the class Decision). If it returns nullptr, this means that the decision builder has finished its work.

def DebugString(self):
2049    def DebugString(self):
2050        return _pywrapcp.DecisionBuilder_DebugString(self)
class Demon(BaseObject):
2064class Demon(BaseObject):
2065    r"""
2066    A Demon is the base element of a propagation queue. It is the main
2067      object responsible for implementing the actual propagation
2068      of the constraint and pruning the inconsistent values in the domains
2069      of the variables. The main concept is that demons are listeners that are
2070      attached to the variables and listen to their modifications.
2071    There are two methods:
2072     - Run() is the actual method called when the demon is processed.
2073     - priority() returns its priority. Standard priorities are slow, normal
2074       or fast. "immediate" is reserved for variables and is treated separately.
2075    """
2076
2077    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2078    __repr__ = _swig_repr
2079
2080    def __init__(self):
2081        r"""
2082        This indicates the priority of a demon. Immediate demons are treated
2083        separately and corresponds to variables.
2084        """
2085        if self.__class__ == Demon:
2086            _self = None
2087        else:
2088            _self = self
2089        _pywrapcp.Demon_swiginit(self, _pywrapcp.new_Demon(_self, ))
2090    __swig_destroy__ = _pywrapcp.delete_Demon
2091
2092    def RunWrapper(self, s):
2093        r""" This is the main callback of the demon."""
2094        return _pywrapcp.Demon_RunWrapper(self, s)
2095
2096    def Priority(self):
2097        r"""
2098        This method returns the priority of the demon. Usually a demon is
2099        fast, slow or normal. Immediate demons are reserved for internal
2100        use to maintain variables.
2101        """
2102        return _pywrapcp.Demon_Priority(self)
2103
2104    def DebugString(self):
2105        return _pywrapcp.Demon_DebugString(self)
2106
2107    def Inhibit(self, s):
2108        r"""
2109        This method inhibits the demon in the search tree below the
2110        current position.
2111        """
2112        return _pywrapcp.Demon_Inhibit(self, s)
2113
2114    def Desinhibit(self, s):
2115        r""" This method un-inhibits the demon that was previously inhibited."""
2116        return _pywrapcp.Demon_Desinhibit(self, s)
2117    def __disown__(self):
2118        self.this.disown()
2119        _pywrapcp.disown_Demon(self)
2120        return weakref.proxy(self)

A Demon is the base element of a propagation queue. It is the main object responsible for implementing the actual propagation of the constraint and pruning the inconsistent values in the domains of the variables. The main concept is that demons are listeners that are attached to the variables and listen to their modifications.

There are two methods:
  • Run() is the actual method called when the demon is processed.
  • priority() returns its priority. Standard priorities are slow, normal or fast. "immediate" is reserved for variables and is treated separately.
Demon()
2080    def __init__(self):
2081        r"""
2082        This indicates the priority of a demon. Immediate demons are treated
2083        separately and corresponds to variables.
2084        """
2085        if self.__class__ == Demon:
2086            _self = None
2087        else:
2088            _self = self
2089        _pywrapcp.Demon_swiginit(self, _pywrapcp.new_Demon(_self, ))

This indicates the priority of a demon. Immediate demons are treated separately and corresponds to variables.

thisown

The membership flag

def RunWrapper(self, s):
2092    def RunWrapper(self, s):
2093        r""" This is the main callback of the demon."""
2094        return _pywrapcp.Demon_RunWrapper(self, s)

This is the main callback of the demon.

def Priority(self):
2096    def Priority(self):
2097        r"""
2098        This method returns the priority of the demon. Usually a demon is
2099        fast, slow or normal. Immediate demons are reserved for internal
2100        use to maintain variables.
2101        """
2102        return _pywrapcp.Demon_Priority(self)

This method returns the priority of the demon. Usually a demon is fast, slow or normal. Immediate demons are reserved for internal use to maintain variables.

def DebugString(self):
2104    def DebugString(self):
2105        return _pywrapcp.Demon_DebugString(self)
def Inhibit(self, s):
2107    def Inhibit(self, s):
2108        r"""
2109        This method inhibits the demon in the search tree below the
2110        current position.
2111        """
2112        return _pywrapcp.Demon_Inhibit(self, s)

This method inhibits the demon in the search tree below the current position.

def Desinhibit(self, s):
2114    def Desinhibit(self, s):
2115        r""" This method un-inhibits the demon that was previously inhibited."""
2116        return _pywrapcp.Demon_Desinhibit(self, s)

This method un-inhibits the demon that was previously inhibited.

class Constraint(PropagationBaseObject):
2124class Constraint(PropagationBaseObject):
2125    r"""
2126    A constraint is the main modeling object. It provides two methods:
2127      - Post() is responsible for creating the demons and attaching them to
2128        immediate demons().
2129      - InitialPropagate() is called once just after Post and performs
2130        the initial propagation. The subsequent propagations will be performed
2131        by the demons Posted during the post() method.
2132    """
2133
2134    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2135
2136    def __init__(self, solver):
2137        if self.__class__ == Constraint:
2138            _self = None
2139        else:
2140            _self = self
2141        _pywrapcp.Constraint_swiginit(self, _pywrapcp.new_Constraint(_self, solver))
2142    __swig_destroy__ = _pywrapcp.delete_Constraint
2143
2144    def Post(self):
2145        r"""
2146        This method is called when the constraint is processed by the
2147        solver. Its main usage is to attach demons to variables.
2148        """
2149        return _pywrapcp.Constraint_Post(self)
2150
2151    def InitialPropagateWrapper(self):
2152        r"""
2153        This method performs the initial propagation of the
2154        constraint. It is called just after the post.
2155        """
2156        return _pywrapcp.Constraint_InitialPropagateWrapper(self)
2157
2158    def DebugString(self):
2159        return _pywrapcp.Constraint_DebugString(self)
2160
2161    def Var(self):
2162        r"""
2163        Creates a Boolean variable representing the status of the constraint
2164        (false = constraint is violated, true = constraint is satisfied). It
2165        returns nullptr if the constraint does not support this API.
2166        """
2167        return _pywrapcp.Constraint_Var(self)
2168
2169    def __repr__(self):
2170        return _pywrapcp.Constraint___repr__(self)
2171
2172    def __str__(self):
2173        return _pywrapcp.Constraint___str__(self)
2174
2175    def __add__(self, *args):
2176        return _pywrapcp.Constraint___add__(self, *args)
2177
2178    def __radd__(self, v):
2179        return _pywrapcp.Constraint___radd__(self, v)
2180
2181    def __sub__(self, *args):
2182        return _pywrapcp.Constraint___sub__(self, *args)
2183
2184    def __rsub__(self, v):
2185        return _pywrapcp.Constraint___rsub__(self, v)
2186
2187    def __mul__(self, *args):
2188        return _pywrapcp.Constraint___mul__(self, *args)
2189
2190    def __rmul__(self, v):
2191        return _pywrapcp.Constraint___rmul__(self, v)
2192
2193    def __floordiv__(self, v):
2194        return _pywrapcp.Constraint___floordiv__(self, v)
2195
2196    def __neg__(self):
2197        return _pywrapcp.Constraint___neg__(self)
2198
2199    def __abs__(self):
2200        return _pywrapcp.Constraint___abs__(self)
2201
2202    def Square(self):
2203        return _pywrapcp.Constraint_Square(self)
2204
2205    def __eq__(self, *args):
2206        return _pywrapcp.Constraint___eq__(self, *args)
2207
2208    def __ne__(self, *args):
2209        return _pywrapcp.Constraint___ne__(self, *args)
2210
2211    def __ge__(self, *args):
2212        return _pywrapcp.Constraint___ge__(self, *args)
2213
2214    def __gt__(self, *args):
2215        return _pywrapcp.Constraint___gt__(self, *args)
2216
2217    def __le__(self, *args):
2218        return _pywrapcp.Constraint___le__(self, *args)
2219
2220    def __lt__(self, *args):
2221        return _pywrapcp.Constraint___lt__(self, *args)
2222
2223    def MapTo(self, vars):
2224        return _pywrapcp.Constraint_MapTo(self, vars)
2225
2226    def IndexOf(self, *args):
2227        return _pywrapcp.Constraint_IndexOf(self, *args)
2228    def __disown__(self):
2229        self.this.disown()
2230        _pywrapcp.disown_Constraint(self)
2231        return weakref.proxy(self)

A constraint is the main modeling object. It provides two methods:

  • Post() is responsible for creating the demons and attaching them to immediate demons().
  • InitialPropagate() is called once just after Post and performs the initial propagation. The subsequent propagations will be performed by the demons Posted during the post() method.
Constraint(solver)
2136    def __init__(self, solver):
2137        if self.__class__ == Constraint:
2138            _self = None
2139        else:
2140            _self = self
2141        _pywrapcp.Constraint_swiginit(self, _pywrapcp.new_Constraint(_self, solver))
thisown

The membership flag

def Post(self):
2144    def Post(self):
2145        r"""
2146        This method is called when the constraint is processed by the
2147        solver. Its main usage is to attach demons to variables.
2148        """
2149        return _pywrapcp.Constraint_Post(self)

This method is called when the constraint is processed by the solver. Its main usage is to attach demons to variables.

def InitialPropagateWrapper(self):
2151    def InitialPropagateWrapper(self):
2152        r"""
2153        This method performs the initial propagation of the
2154        constraint. It is called just after the post.
2155        """
2156        return _pywrapcp.Constraint_InitialPropagateWrapper(self)

This method performs the initial propagation of the constraint. It is called just after the post.

def DebugString(self):
2158    def DebugString(self):
2159        return _pywrapcp.Constraint_DebugString(self)
def Var(self):
2161    def Var(self):
2162        r"""
2163        Creates a Boolean variable representing the status of the constraint
2164        (false = constraint is violated, true = constraint is satisfied). It
2165        returns nullptr if the constraint does not support this API.
2166        """
2167        return _pywrapcp.Constraint_Var(self)

Creates a Boolean variable representing the status of the constraint (false = constraint is violated, true = constraint is satisfied). It returns nullptr if the constraint does not support this API.

def Square(self):
2202    def Square(self):
2203        return _pywrapcp.Constraint_Square(self)
def MapTo(self, vars):
2223    def MapTo(self, vars):
2224        return _pywrapcp.Constraint_MapTo(self, vars)
def IndexOf(self, *args):
2226    def IndexOf(self, *args):
2227        return _pywrapcp.Constraint_IndexOf(self, *args)
Inherited Members
PropagationBaseObject
solver
Name
class SearchMonitor(BaseObject):
2235class SearchMonitor(BaseObject):
2236    r""" A search monitor is a simple set of callbacks to monitor all search events"""
2237
2238    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2239    kNoProgress = _pywrapcp.SearchMonitor_kNoProgress
2240
2241    def __init__(self, s):
2242        if self.__class__ == SearchMonitor:
2243            _self = None
2244        else:
2245            _self = self
2246        _pywrapcp.SearchMonitor_swiginit(self, _pywrapcp.new_SearchMonitor(_self, s))
2247    __swig_destroy__ = _pywrapcp.delete_SearchMonitor
2248
2249    def EnterSearch(self):
2250        r""" Beginning of the search."""
2251        return _pywrapcp.SearchMonitor_EnterSearch(self)
2252
2253    def RestartSearch(self):
2254        r""" Restart the search."""
2255        return _pywrapcp.SearchMonitor_RestartSearch(self)
2256
2257    def ExitSearch(self):
2258        r""" End of the search."""
2259        return _pywrapcp.SearchMonitor_ExitSearch(self)
2260
2261    def BeginNextDecision(self, b):
2262        r""" Before calling DecisionBuilder::Next."""
2263        return _pywrapcp.SearchMonitor_BeginNextDecision(self, b)
2264
2265    def EndNextDecision(self, b, d):
2266        r""" After calling DecisionBuilder::Next, along with the returned decision."""
2267        return _pywrapcp.SearchMonitor_EndNextDecision(self, b, d)
2268
2269    def ApplyDecision(self, d):
2270        r""" Before applying the decision."""
2271        return _pywrapcp.SearchMonitor_ApplyDecision(self, d)
2272
2273    def RefuteDecision(self, d):
2274        r""" Before refuting the decision."""
2275        return _pywrapcp.SearchMonitor_RefuteDecision(self, d)
2276
2277    def AfterDecision(self, d, apply):
2278        r"""
2279        Just after refuting or applying the decision, apply is true after Apply.
2280        This is called only if the Apply() or Refute() methods have not failed.
2281        """
2282        return _pywrapcp.SearchMonitor_AfterDecision(self, d, apply)
2283
2284    def BeginFail(self):
2285        r""" Just when the failure occurs."""
2286        return _pywrapcp.SearchMonitor_BeginFail(self)
2287
2288    def EndFail(self):
2289        r""" After completing the backtrack."""
2290        return _pywrapcp.SearchMonitor_EndFail(self)
2291
2292    def BeginInitialPropagation(self):
2293        r""" Before the initial propagation."""
2294        return _pywrapcp.SearchMonitor_BeginInitialPropagation(self)
2295
2296    def EndInitialPropagation(self):
2297        r""" After the initial propagation."""
2298        return _pywrapcp.SearchMonitor_EndInitialPropagation(self)
2299
2300    def AcceptSolution(self):
2301        r"""
2302        This method is called when a solution is found. It asserts whether the
2303        solution is valid. A value of false indicates that the solution
2304        should be discarded.
2305        """
2306        return _pywrapcp.SearchMonitor_AcceptSolution(self)
2307
2308    def AtSolution(self):
2309        r"""
2310        This method is called when a valid solution is found. If the
2311        return value is true, then search will resume after. If the result
2312        is false, then search will stop there.
2313        """
2314        return _pywrapcp.SearchMonitor_AtSolution(self)
2315
2316    def NoMoreSolutions(self):
2317        r""" When the search tree is finished."""
2318        return _pywrapcp.SearchMonitor_NoMoreSolutions(self)
2319
2320    def LocalOptimum(self):
2321        r"""
2322        When a local optimum is reached. If 'true' is returned, the last solution
2323        is discarded and the search proceeds with the next one.
2324        """
2325        return _pywrapcp.SearchMonitor_LocalOptimum(self)
2326
2327    def AcceptDelta(self, delta, deltadelta):
2328        
2329        return _pywrapcp.SearchMonitor_AcceptDelta(self, delta, deltadelta)
2330
2331    def AcceptNeighbor(self):
2332        r""" After accepting a neighbor during local search."""
2333        return _pywrapcp.SearchMonitor_AcceptNeighbor(self)
2334
2335    def ProgressPercent(self):
2336        r"""
2337        Returns a percentage representing the propress of the search before
2338        reaching limits.
2339        """
2340        return _pywrapcp.SearchMonitor_ProgressPercent(self)
2341
2342    def solver(self):
2343        return _pywrapcp.SearchMonitor_solver(self)
2344
2345    def __repr__(self):
2346        return _pywrapcp.SearchMonitor___repr__(self)
2347
2348    def __str__(self):
2349        return _pywrapcp.SearchMonitor___str__(self)
2350    def __disown__(self):
2351        self.this.disown()
2352        _pywrapcp.disown_SearchMonitor(self)
2353        return weakref.proxy(self)

A search monitor is a simple set of callbacks to monitor all search events

SearchMonitor(s)
2241    def __init__(self, s):
2242        if self.__class__ == SearchMonitor:
2243            _self = None
2244        else:
2245            _self = self
2246        _pywrapcp.SearchMonitor_swiginit(self, _pywrapcp.new_SearchMonitor(_self, s))
thisown

The membership flag

kNoProgress = -1
def EnterSearch(self):
2249    def EnterSearch(self):
2250        r""" Beginning of the search."""
2251        return _pywrapcp.SearchMonitor_EnterSearch(self)

Beginning of the search.

def RestartSearch(self):
2253    def RestartSearch(self):
2254        r""" Restart the search."""
2255        return _pywrapcp.SearchMonitor_RestartSearch(self)

Restart the search.

def ExitSearch(self):
2257    def ExitSearch(self):
2258        r""" End of the search."""
2259        return _pywrapcp.SearchMonitor_ExitSearch(self)

End of the search.

def BeginNextDecision(self, b):
2261    def BeginNextDecision(self, b):
2262        r""" Before calling DecisionBuilder::Next."""
2263        return _pywrapcp.SearchMonitor_BeginNextDecision(self, b)

Before calling DecisionBuilder::Next.

def EndNextDecision(self, b, d):
2265    def EndNextDecision(self, b, d):
2266        r""" After calling DecisionBuilder::Next, along with the returned decision."""
2267        return _pywrapcp.SearchMonitor_EndNextDecision(self, b, d)

After calling DecisionBuilder::Next, along with the returned decision.

def ApplyDecision(self, d):
2269    def ApplyDecision(self, d):
2270        r""" Before applying the decision."""
2271        return _pywrapcp.SearchMonitor_ApplyDecision(self, d)

Before applying the decision.

def RefuteDecision(self, d):
2273    def RefuteDecision(self, d):
2274        r""" Before refuting the decision."""
2275        return _pywrapcp.SearchMonitor_RefuteDecision(self, d)

Before refuting the decision.

def AfterDecision(self, d, apply):
2277    def AfterDecision(self, d, apply):
2278        r"""
2279        Just after refuting or applying the decision, apply is true after Apply.
2280        This is called only if the Apply() or Refute() methods have not failed.
2281        """
2282        return _pywrapcp.SearchMonitor_AfterDecision(self, d, apply)

Just after refuting or applying the decision, apply is true after Apply. This is called only if the Apply() or Refute() methods have not failed.

def BeginFail(self):
2284    def BeginFail(self):
2285        r""" Just when the failure occurs."""
2286        return _pywrapcp.SearchMonitor_BeginFail(self)

Just when the failure occurs.

def EndFail(self):
2288    def EndFail(self):
2289        r""" After completing the backtrack."""
2290        return _pywrapcp.SearchMonitor_EndFail(self)

After completing the backtrack.

def BeginInitialPropagation(self):
2292    def BeginInitialPropagation(self):
2293        r""" Before the initial propagation."""
2294        return _pywrapcp.SearchMonitor_BeginInitialPropagation(self)

Before the initial propagation.

def EndInitialPropagation(self):
2296    def EndInitialPropagation(self):
2297        r""" After the initial propagation."""
2298        return _pywrapcp.SearchMonitor_EndInitialPropagation(self)

After the initial propagation.

def AcceptSolution(self):
2300    def AcceptSolution(self):
2301        r"""
2302        This method is called when a solution is found. It asserts whether the
2303        solution is valid. A value of false indicates that the solution
2304        should be discarded.
2305        """
2306        return _pywrapcp.SearchMonitor_AcceptSolution(self)

This method is called when a solution is found. It asserts whether the solution is valid. A value of false indicates that the solution should be discarded.

def AtSolution(self):
2308    def AtSolution(self):
2309        r"""
2310        This method is called when a valid solution is found. If the
2311        return value is true, then search will resume after. If the result
2312        is false, then search will stop there.
2313        """
2314        return _pywrapcp.SearchMonitor_AtSolution(self)

This method is called when a valid solution is found. If the return value is true, then search will resume after. If the result is false, then search will stop there.

def NoMoreSolutions(self):
2316    def NoMoreSolutions(self):
2317        r""" When the search tree is finished."""
2318        return _pywrapcp.SearchMonitor_NoMoreSolutions(self)

When the search tree is finished.

def LocalOptimum(self):
2320    def LocalOptimum(self):
2321        r"""
2322        When a local optimum is reached. If 'true' is returned, the last solution
2323        is discarded and the search proceeds with the next one.
2324        """
2325        return _pywrapcp.SearchMonitor_LocalOptimum(self)

When a local optimum is reached. If 'true' is returned, the last solution is discarded and the search proceeds with the next one.

def AcceptDelta(self, delta, deltadelta):
2327    def AcceptDelta(self, delta, deltadelta):
2328        
2329        return _pywrapcp.SearchMonitor_AcceptDelta(self, delta, deltadelta)
def AcceptNeighbor(self):
2331    def AcceptNeighbor(self):
2332        r""" After accepting a neighbor during local search."""
2333        return _pywrapcp.SearchMonitor_AcceptNeighbor(self)

After accepting a neighbor during local search.

def ProgressPercent(self):
2335    def ProgressPercent(self):
2336        r"""
2337        Returns a percentage representing the propress of the search before
2338        reaching limits.
2339        """
2340        return _pywrapcp.SearchMonitor_ProgressPercent(self)

Returns a percentage representing the propress of the search before reaching limits.

def solver(self):
2342    def solver(self):
2343        return _pywrapcp.SearchMonitor_solver(self)
Inherited Members
BaseObject
DebugString
class IntExpr(PropagationBaseObject):
2357class IntExpr(PropagationBaseObject):
2358    r"""
2359    The class IntExpr is the base of all integer expressions in
2360    constraint programming.
2361    It contains the basic protocol for an expression:
2362      - setting and modifying its bound
2363      - querying if it is bound
2364      - listening to events modifying its bounds
2365      - casting it into a variable (instance of IntVar)
2366    """
2367
2368    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2369
2370    def __init__(self, *args, **kwargs):
2371        raise AttributeError("No constructor defined - class is abstract")
2372
2373    def Min(self):
2374        return _pywrapcp.IntExpr_Min(self)
2375
2376    def SetMin(self, m):
2377        return _pywrapcp.IntExpr_SetMin(self, m)
2378
2379    def Max(self):
2380        return _pywrapcp.IntExpr_Max(self)
2381
2382    def SetMax(self, m):
2383        return _pywrapcp.IntExpr_SetMax(self, m)
2384
2385    def SetRange(self, l, u):
2386        r""" This method sets both the min and the max of the expression."""
2387        return _pywrapcp.IntExpr_SetRange(self, l, u)
2388
2389    def SetValue(self, v):
2390        r""" This method sets the value of the expression."""
2391        return _pywrapcp.IntExpr_SetValue(self, v)
2392
2393    def Bound(self):
2394        r""" Returns true if the min and the max of the expression are equal."""
2395        return _pywrapcp.IntExpr_Bound(self)
2396
2397    def IsVar(self):
2398        r""" Returns true if the expression is indeed a variable."""
2399        return _pywrapcp.IntExpr_IsVar(self)
2400
2401    def Var(self):
2402        r""" Creates a variable from the expression."""
2403        return _pywrapcp.IntExpr_Var(self)
2404
2405    def VarWithName(self, name):
2406        r"""
2407        Creates a variable from the expression and set the name of the
2408        resulting var. If the expression is already a variable, then it
2409        will set the name of the expression, possibly overwriting it.
2410        This is just a shortcut to Var() followed by set_name().
2411        """
2412        return _pywrapcp.IntExpr_VarWithName(self, name)
2413
2414    def WhenRange(self, *args):
2415        r"""
2416        *Overload 1:*
2417        Attach a demon that will watch the min or the max of the expression.
2418
2419        |
2420
2421        *Overload 2:*
2422        Attach a demon that will watch the min or the max of the expression.
2423        """
2424        return _pywrapcp.IntExpr_WhenRange(self, *args)
2425
2426    def __repr__(self):
2427        return _pywrapcp.IntExpr___repr__(self)
2428
2429    def __str__(self):
2430        return _pywrapcp.IntExpr___str__(self)
2431
2432    def __add__(self, *args):
2433        return _pywrapcp.IntExpr___add__(self, *args)
2434
2435    def __radd__(self, v):
2436        return _pywrapcp.IntExpr___radd__(self, v)
2437
2438    def __sub__(self, *args):
2439        return _pywrapcp.IntExpr___sub__(self, *args)
2440
2441    def __rsub__(self, v):
2442        return _pywrapcp.IntExpr___rsub__(self, v)
2443
2444    def __mul__(self, *args):
2445        return _pywrapcp.IntExpr___mul__(self, *args)
2446
2447    def __rmul__(self, v):
2448        return _pywrapcp.IntExpr___rmul__(self, v)
2449
2450    def __floordiv__(self, *args):
2451        return _pywrapcp.IntExpr___floordiv__(self, *args)
2452
2453    def __mod__(self, *args):
2454        return _pywrapcp.IntExpr___mod__(self, *args)
2455
2456    def __neg__(self):
2457        return _pywrapcp.IntExpr___neg__(self)
2458
2459    def __abs__(self):
2460        return _pywrapcp.IntExpr___abs__(self)
2461
2462    def Square(self):
2463        return _pywrapcp.IntExpr_Square(self)
2464
2465    def __eq__(self, *args):
2466        return _pywrapcp.IntExpr___eq__(self, *args)
2467
2468    def __ne__(self, *args):
2469        return _pywrapcp.IntExpr___ne__(self, *args)
2470
2471    def __ge__(self, *args):
2472        return _pywrapcp.IntExpr___ge__(self, *args)
2473
2474    def __gt__(self, *args):
2475        return _pywrapcp.IntExpr___gt__(self, *args)
2476
2477    def __le__(self, *args):
2478        return _pywrapcp.IntExpr___le__(self, *args)
2479
2480    def __lt__(self, *args):
2481        return _pywrapcp.IntExpr___lt__(self, *args)
2482
2483    def MapTo(self, vars):
2484        return _pywrapcp.IntExpr_MapTo(self, vars)
2485
2486    def IndexOf(self, *args):
2487        return _pywrapcp.IntExpr_IndexOf(self, *args)
2488
2489    def IsMember(self, values):
2490        return _pywrapcp.IntExpr_IsMember(self, values)
2491
2492    def Member(self, values):
2493        return _pywrapcp.IntExpr_Member(self, values)
2494
2495    def NotMember(self, starts, ends):
2496        return _pywrapcp.IntExpr_NotMember(self, starts, ends)

The class IntExpr is the base of all integer expressions in constraint programming.

It contains the basic protocol for an expression:
  • setting and modifying its bound
  • querying if it is bound
  • listening to events modifying its bounds
  • casting it into a variable (instance of IntVar)
IntExpr(*args, **kwargs)
2370    def __init__(self, *args, **kwargs):
2371        raise AttributeError("No constructor defined - class is abstract")
thisown

The membership flag

def Min(self):
2373    def Min(self):
2374        return _pywrapcp.IntExpr_Min(self)
def SetMin(self, m):
2376    def SetMin(self, m):
2377        return _pywrapcp.IntExpr_SetMin(self, m)
def Max(self):
2379    def Max(self):
2380        return _pywrapcp.IntExpr_Max(self)
def SetMax(self, m):
2382    def SetMax(self, m):
2383        return _pywrapcp.IntExpr_SetMax(self, m)
def SetRange(self, l, u):
2385    def SetRange(self, l, u):
2386        r""" This method sets both the min and the max of the expression."""
2387        return _pywrapcp.IntExpr_SetRange(self, l, u)

This method sets both the min and the max of the expression.

def SetValue(self, v):
2389    def SetValue(self, v):
2390        r""" This method sets the value of the expression."""
2391        return _pywrapcp.IntExpr_SetValue(self, v)

This method sets the value of the expression.

def Bound(self):
2393    def Bound(self):
2394        r""" Returns true if the min and the max of the expression are equal."""
2395        return _pywrapcp.IntExpr_Bound(self)

Returns true if the min and the max of the expression are equal.

def IsVar(self):
2397    def IsVar(self):
2398        r""" Returns true if the expression is indeed a variable."""
2399        return _pywrapcp.IntExpr_IsVar(self)

Returns true if the expression is indeed a variable.

def Var(self):
2401    def Var(self):
2402        r""" Creates a variable from the expression."""
2403        return _pywrapcp.IntExpr_Var(self)

Creates a variable from the expression.

def VarWithName(self, name):
2405    def VarWithName(self, name):
2406        r"""
2407        Creates a variable from the expression and set the name of the
2408        resulting var. If the expression is already a variable, then it
2409        will set the name of the expression, possibly overwriting it.
2410        This is just a shortcut to Var() followed by set_name().
2411        """
2412        return _pywrapcp.IntExpr_VarWithName(self, name)

Creates a variable from the expression and set the name of the resulting var. If the expression is already a variable, then it will set the name of the expression, possibly overwriting it. This is just a shortcut to Var() followed by set_name().

def WhenRange(self, *args):
2414    def WhenRange(self, *args):
2415        r"""
2416        *Overload 1:*
2417        Attach a demon that will watch the min or the max of the expression.
2418
2419        |
2420
2421        *Overload 2:*
2422        Attach a demon that will watch the min or the max of the expression.
2423        """
2424        return _pywrapcp.IntExpr_WhenRange(self, *args)

Overload 1: Attach a demon that will watch the min or the max of the expression.

|

Overload 2: Attach a demon that will watch the min or the max of the expression.

def Square(self):
2462    def Square(self):
2463        return _pywrapcp.IntExpr_Square(self)
def MapTo(self, vars):
2483    def MapTo(self, vars):
2484        return _pywrapcp.IntExpr_MapTo(self, vars)
def IndexOf(self, *args):
2486    def IndexOf(self, *args):
2487        return _pywrapcp.IntExpr_IndexOf(self, *args)
def IsMember(self, values):
2489    def IsMember(self, values):
2490        return _pywrapcp.IntExpr_IsMember(self, values)
def Member(self, values):
2492    def Member(self, values):
2493        return _pywrapcp.IntExpr_Member(self, values)
def NotMember(self, starts, ends):
2495    def NotMember(self, starts, ends):
2496        return _pywrapcp.IntExpr_NotMember(self, starts, ends)
class IntVarIterator(BaseObject):
2500class IntVarIterator(BaseObject):
2501    r"""
2502     The class Iterator has two direct subclasses. HoleIterators
2503     iterates over all holes, that is value removed between the
2504     current min and max of the variable since the last time the
2505     variable was processed in the queue. DomainIterators iterates
2506     over all elements of the variable domain. Both iterators are not
2507     robust to domain changes. Hole iterators can also report values outside
2508     the current min and max of the variable.
2509     HoleIterators should only be called from a demon attached to the
2510     variable that has created this iterator.
2511     IntVar* current_var;
2512     std::unique_ptr<IntVarIterator> it(current_var->MakeHoleIterator(false));
2513     for (const int64_t hole : InitAndGetValues(it)) {
2514    use the hole
2515     }
2516    """
2517
2518    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2519
2520    def __init__(self, *args, **kwargs):
2521        raise AttributeError("No constructor defined - class is abstract")
2522    __repr__ = _swig_repr
2523
2524    def Init(self):
2525        r""" This method must be called before each loop."""
2526        return _pywrapcp.IntVarIterator_Init(self)
2527
2528    def Ok(self):
2529        r""" This method indicates if we can call Value() or not."""
2530        return _pywrapcp.IntVarIterator_Ok(self)
2531
2532    def Value(self):
2533        r""" This method returns the current value of the iterator."""
2534        return _pywrapcp.IntVarIterator_Value(self)
2535
2536    def Next(self):
2537        r""" This method moves the iterator to the next value."""
2538        return _pywrapcp.IntVarIterator_Next(self)
2539
2540    def DebugString(self):
2541        r""" Pretty Print."""
2542        return _pywrapcp.IntVarIterator_DebugString(self)
2543
2544    def __iter__(self):
2545      self.Init()
2546      return self
2547
2548    def next(self):
2549      if self.Ok():
2550        result = self.Value()
2551        self.Next()
2552        return result
2553      else:
2554        raise StopIteration()
2555
2556    def __next__(self):
2557      return self.next()

The class Iterator has two direct subclasses. HoleIterators iterates over all holes, that is value removed between the current min and max of the variable since the last time the variable was processed in the queue. DomainIterators iterates over all elements of the variable domain. Both iterators are not robust to domain changes. Hole iterators can also report values outside the current min and max of the variable. HoleIterators should only be called from a demon attached to the variable that has created this iterator. IntVar* current_var; std::unique_ptr it(current_var->MakeHoleIterator(false)); for (const int64_t hole : InitAndGetValues(it)) { use the hole }

IntVarIterator(*args, **kwargs)
2520    def __init__(self, *args, **kwargs):
2521        raise AttributeError("No constructor defined - class is abstract")
thisown

The membership flag

def Init(self):
2524    def Init(self):
2525        r""" This method must be called before each loop."""
2526        return _pywrapcp.IntVarIterator_Init(self)

This method must be called before each loop.

def Ok(self):
2528    def Ok(self):
2529        r""" This method indicates if we can call Value() or not."""
2530        return _pywrapcp.IntVarIterator_Ok(self)

This method indicates if we can call Value() or not.

def Value(self):
2532    def Value(self):
2533        r""" This method returns the current value of the iterator."""
2534        return _pywrapcp.IntVarIterator_Value(self)

This method returns the current value of the iterator.

def Next(self):
2536    def Next(self):
2537        r""" This method moves the iterator to the next value."""
2538        return _pywrapcp.IntVarIterator_Next(self)

This method moves the iterator to the next value.

def DebugString(self):
2540    def DebugString(self):
2541        r""" Pretty Print."""
2542        return _pywrapcp.IntVarIterator_DebugString(self)

Pretty Print.

def next(self):
2548    def next(self):
2549      if self.Ok():
2550        result = self.Value()
2551        self.Next()
2552        return result
2553      else:
2554        raise StopIteration()
class IntVar(IntExpr):
2562class IntVar(IntExpr):
2563    r"""
2564    The class IntVar is a subset of IntExpr. In addition to the
2565    IntExpr protocol, it offers persistence, removing values from the domains,
2566    and a finer model for events.
2567    """
2568
2569    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2570
2571    def __init__(self, *args, **kwargs):
2572        raise AttributeError("No constructor defined - class is abstract")
2573
2574    def IsVar(self):
2575        return _pywrapcp.IntVar_IsVar(self)
2576
2577    def Var(self):
2578        return _pywrapcp.IntVar_Var(self)
2579
2580    def Value(self):
2581        r"""
2582        This method returns the value of the variable. This method checks
2583        before that the variable is bound.
2584        """
2585        return _pywrapcp.IntVar_Value(self)
2586
2587    def RemoveValue(self, v):
2588        r""" This method removes the value 'v' from the domain of the variable."""
2589        return _pywrapcp.IntVar_RemoveValue(self, v)
2590
2591    def RemoveInterval(self, l, u):
2592        r"""
2593        This method removes the interval 'l' .. 'u' from the domain of
2594        the variable. It assumes that 'l' <= 'u'.
2595        """
2596        return _pywrapcp.IntVar_RemoveInterval(self, l, u)
2597
2598    def RemoveValues(self, values):
2599        r""" This method remove the values from the domain of the variable."""
2600        return _pywrapcp.IntVar_RemoveValues(self, values)
2601
2602    def SetValues(self, values):
2603        r""" This method intersects the current domain with the values in the array."""
2604        return _pywrapcp.IntVar_SetValues(self, values)
2605
2606    def WhenBound(self, *args):
2607        r"""
2608        *Overload 1:*
2609        This method attaches a demon that will be awakened when the
2610        variable is bound.
2611
2612        |
2613
2614        *Overload 2:*
2615        This method attaches a closure that will be awakened when the
2616        variable is bound.
2617        """
2618        return _pywrapcp.IntVar_WhenBound(self, *args)
2619
2620    def WhenDomain(self, *args):
2621        r"""
2622        *Overload 1:*
2623        This method attaches a demon that will watch any domain
2624        modification of the domain of the variable.
2625
2626        |
2627
2628        *Overload 2:*
2629        This method attaches a closure that will watch any domain
2630        modification of the domain of the variable.
2631        """
2632        return _pywrapcp.IntVar_WhenDomain(self, *args)
2633
2634    def Size(self):
2635        r""" This method returns the number of values in the domain of the variable."""
2636        return _pywrapcp.IntVar_Size(self)
2637
2638    def Contains(self, v):
2639        r"""
2640        This method returns whether the value 'v' is in the domain of the
2641        variable.
2642        """
2643        return _pywrapcp.IntVar_Contains(self, v)
2644
2645    def HoleIteratorAux(self, reversible):
2646        r"""
2647        Creates a hole iterator. When 'reversible' is false, the returned
2648        object is created on the normal C++ heap and the solver does NOT
2649        take ownership of the object.
2650        """
2651        return _pywrapcp.IntVar_HoleIteratorAux(self, reversible)
2652
2653    def DomainIteratorAux(self, reversible):
2654        r"""
2655        Creates a domain iterator. When 'reversible' is false, the
2656        returned object is created on the normal C++ heap and the solver
2657        does NOT take ownership of the object.
2658        """
2659        return _pywrapcp.IntVar_DomainIteratorAux(self, reversible)
2660
2661    def OldMin(self):
2662        r""" Returns the previous min."""
2663        return _pywrapcp.IntVar_OldMin(self)
2664
2665    def OldMax(self):
2666        r""" Returns the previous max."""
2667        return _pywrapcp.IntVar_OldMax(self)
2668
2669    def __repr__(self):
2670        return _pywrapcp.IntVar___repr__(self)
2671
2672    def __str__(self):
2673        return _pywrapcp.IntVar___str__(self)
2674
2675    def DomainIterator(self):
2676      return iter(self.DomainIteratorAux(False))
2677
2678    def HoleIterator(self):
2679      return iter(self.HoleIteratorAux(False))

The class IntVar is a subset of IntExpr. In addition to the IntExpr protocol, it offers persistence, removing values from the domains, and a finer model for events.

IntVar(*args, **kwargs)
2571    def __init__(self, *args, **kwargs):
2572        raise AttributeError("No constructor defined - class is abstract")
thisown

The membership flag

def IsVar(self):
2574    def IsVar(self):
2575        return _pywrapcp.IntVar_IsVar(self)

Returns true if the expression is indeed a variable.

def Var(self):
2577    def Var(self):
2578        return _pywrapcp.IntVar_Var(self)

Creates a variable from the expression.

def Value(self):
2580    def Value(self):
2581        r"""
2582        This method returns the value of the variable. This method checks
2583        before that the variable is bound.
2584        """
2585        return _pywrapcp.IntVar_Value(self)

This method returns the value of the variable. This method checks before that the variable is bound.

def RemoveValue(self, v):
2587    def RemoveValue(self, v):
2588        r""" This method removes the value 'v' from the domain of the variable."""
2589        return _pywrapcp.IntVar_RemoveValue(self, v)

This method removes the value 'v' from the domain of the variable.

def RemoveInterval(self, l, u):
2591    def RemoveInterval(self, l, u):
2592        r"""
2593        This method removes the interval 'l' .. 'u' from the domain of
2594        the variable. It assumes that 'l' <= 'u'.
2595        """
2596        return _pywrapcp.IntVar_RemoveInterval(self, l, u)

This method removes the interval 'l' .. 'u' from the domain of the variable. It assumes that 'l' <= 'u'.

def RemoveValues(self, values):
2598    def RemoveValues(self, values):
2599        r""" This method remove the values from the domain of the variable."""
2600        return _pywrapcp.IntVar_RemoveValues(self, values)

This method remove the values from the domain of the variable.

def SetValues(self, values):
2602    def SetValues(self, values):
2603        r""" This method intersects the current domain with the values in the array."""
2604        return _pywrapcp.IntVar_SetValues(self, values)

This method intersects the current domain with the values in the array.

def WhenBound(self, *args):
2606    def WhenBound(self, *args):
2607        r"""
2608        *Overload 1:*
2609        This method attaches a demon that will be awakened when the
2610        variable is bound.
2611
2612        |
2613
2614        *Overload 2:*
2615        This method attaches a closure that will be awakened when the
2616        variable is bound.
2617        """
2618        return _pywrapcp.IntVar_WhenBound(self, *args)

Overload 1: This method attaches a demon that will be awakened when the variable is bound.

|

Overload 2: This method attaches a closure that will be awakened when the variable is bound.

def WhenDomain(self, *args):
2620    def WhenDomain(self, *args):
2621        r"""
2622        *Overload 1:*
2623        This method attaches a demon that will watch any domain
2624        modification of the domain of the variable.
2625
2626        |
2627
2628        *Overload 2:*
2629        This method attaches a closure that will watch any domain
2630        modification of the domain of the variable.
2631        """
2632        return _pywrapcp.IntVar_WhenDomain(self, *args)

Overload 1: This method attaches a demon that will watch any domain modification of the domain of the variable.

|

Overload 2: This method attaches a closure that will watch any domain modification of the domain of the variable.

def Size(self):
2634    def Size(self):
2635        r""" This method returns the number of values in the domain of the variable."""
2636        return _pywrapcp.IntVar_Size(self)

This method returns the number of values in the domain of the variable.

def Contains(self, v):
2638    def Contains(self, v):
2639        r"""
2640        This method returns whether the value 'v' is in the domain of the
2641        variable.
2642        """
2643        return _pywrapcp.IntVar_Contains(self, v)

This method returns whether the value 'v' is in the domain of the variable.

def HoleIteratorAux(self, reversible):
2645    def HoleIteratorAux(self, reversible):
2646        r"""
2647        Creates a hole iterator. When 'reversible' is false, the returned
2648        object is created on the normal C++ heap and the solver does NOT
2649        take ownership of the object.
2650        """
2651        return _pywrapcp.IntVar_HoleIteratorAux(self, reversible)

Creates a hole iterator. When 'reversible' is false, the returned object is created on the normal C++ heap and the solver does NOT take ownership of the object.

def DomainIteratorAux(self, reversible):
2653    def DomainIteratorAux(self, reversible):
2654        r"""
2655        Creates a domain iterator. When 'reversible' is false, the
2656        returned object is created on the normal C++ heap and the solver
2657        does NOT take ownership of the object.
2658        """
2659        return _pywrapcp.IntVar_DomainIteratorAux(self, reversible)

Creates a domain iterator. When 'reversible' is false, the returned object is created on the normal C++ heap and the solver does NOT take ownership of the object.

def OldMin(self):
2661    def OldMin(self):
2662        r""" Returns the previous min."""
2663        return _pywrapcp.IntVar_OldMin(self)

Returns the previous min.

def OldMax(self):
2665    def OldMax(self):
2666        r""" Returns the previous max."""
2667        return _pywrapcp.IntVar_OldMax(self)

Returns the previous max.

def DomainIterator(self):
2675    def DomainIterator(self):
2676      return iter(self.DomainIteratorAux(False))
def HoleIterator(self):
2678    def HoleIterator(self):
2679      return iter(self.HoleIteratorAux(False))
class SolutionCollector(SearchMonitor):
2684class SolutionCollector(SearchMonitor):
2685    r"""
2686    This class is the root class of all solution collectors.
2687    It implements a basic query API to be used independently
2688    of the collector used.
2689    """
2690
2691    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2692
2693    def __init__(self, *args, **kwargs):
2694        raise AttributeError("No constructor defined")
2695    __repr__ = _swig_repr
2696
2697    def DebugString(self):
2698        return _pywrapcp.SolutionCollector_DebugString(self)
2699
2700    def Add(self, *args):
2701        return _pywrapcp.SolutionCollector_Add(self, *args)
2702
2703    def AddObjective(self, objective):
2704        return _pywrapcp.SolutionCollector_AddObjective(self, objective)
2705
2706    def EnterSearch(self):
2707        r""" Beginning of the search."""
2708        return _pywrapcp.SolutionCollector_EnterSearch(self)
2709
2710    def SolutionCount(self):
2711        r""" Returns how many solutions were stored during the search."""
2712        return _pywrapcp.SolutionCollector_SolutionCount(self)
2713
2714    def Solution(self, n):
2715        r""" Returns the nth solution."""
2716        return _pywrapcp.SolutionCollector_Solution(self, n)
2717
2718    def WallTime(self, n):
2719        r""" Returns the wall time in ms for the nth solution."""
2720        return _pywrapcp.SolutionCollector_WallTime(self, n)
2721
2722    def Branches(self, n):
2723        r""" Returns the number of branches when the nth solution was found."""
2724        return _pywrapcp.SolutionCollector_Branches(self, n)
2725
2726    def Failures(self, n):
2727        r"""
2728        Returns the number of failures encountered at the time of the nth
2729        solution.
2730        """
2731        return _pywrapcp.SolutionCollector_Failures(self, n)
2732
2733    def ObjectiveValue(self, n):
2734        r""" Returns the objective value of the nth solution."""
2735        return _pywrapcp.SolutionCollector_ObjectiveValue(self, n)
2736
2737    def Value(self, n, var):
2738        r""" This is a shortcut to get the Value of 'var' in the nth solution."""
2739        return _pywrapcp.SolutionCollector_Value(self, n, var)
2740
2741    def StartValue(self, n, var):
2742        r""" This is a shortcut to get the StartValue of 'var' in the nth solution."""
2743        return _pywrapcp.SolutionCollector_StartValue(self, n, var)
2744
2745    def EndValue(self, n, var):
2746        r""" This is a shortcut to get the EndValue of 'var' in the nth solution."""
2747        return _pywrapcp.SolutionCollector_EndValue(self, n, var)
2748
2749    def DurationValue(self, n, var):
2750        r""" This is a shortcut to get the DurationValue of 'var' in the nth solution."""
2751        return _pywrapcp.SolutionCollector_DurationValue(self, n, var)
2752
2753    def PerformedValue(self, n, var):
2754        r""" This is a shortcut to get the PerformedValue of 'var' in the nth solution."""
2755        return _pywrapcp.SolutionCollector_PerformedValue(self, n, var)
2756
2757    def ForwardSequence(self, n, var):
2758        r"""
2759        This is a shortcut to get the ForwardSequence of 'var' in the
2760        nth solution. The forward sequence is the list of ranked interval
2761        variables starting from the start of the sequence.
2762        """
2763        return _pywrapcp.SolutionCollector_ForwardSequence(self, n, var)
2764
2765    def BackwardSequence(self, n, var):
2766        r"""
2767        This is a shortcut to get the BackwardSequence of 'var' in the
2768        nth solution. The backward sequence is the list of ranked interval
2769        variables starting from the end of the sequence.
2770        """
2771        return _pywrapcp.SolutionCollector_BackwardSequence(self, n, var)
2772
2773    def Unperformed(self, n, var):
2774        r"""
2775        This is a shortcut to get the list of unperformed of 'var' in the
2776        nth solution.
2777        """
2778        return _pywrapcp.SolutionCollector_Unperformed(self, n, var)

This class is the root class of all solution collectors. It implements a basic query API to be used independently of the collector used.

SolutionCollector(*args, **kwargs)
2693    def __init__(self, *args, **kwargs):
2694        raise AttributeError("No constructor defined")
thisown

The membership flag

def DebugString(self):
2697    def DebugString(self):
2698        return _pywrapcp.SolutionCollector_DebugString(self)
def Add(self, *args):
2700    def Add(self, *args):
2701        return _pywrapcp.SolutionCollector_Add(self, *args)
def AddObjective(self, objective):
2703    def AddObjective(self, objective):
2704        return _pywrapcp.SolutionCollector_AddObjective(self, objective)
def EnterSearch(self):
2706    def EnterSearch(self):
2707        r""" Beginning of the search."""
2708        return _pywrapcp.SolutionCollector_EnterSearch(self)

Beginning of the search.

def SolutionCount(self):
2710    def SolutionCount(self):
2711        r""" Returns how many solutions were stored during the search."""
2712        return _pywrapcp.SolutionCollector_SolutionCount(self)

Returns how many solutions were stored during the search.

def Solution(self, n):
2714    def Solution(self, n):
2715        r""" Returns the nth solution."""
2716        return _pywrapcp.SolutionCollector_Solution(self, n)

Returns the nth solution.

def WallTime(self, n):
2718    def WallTime(self, n):
2719        r""" Returns the wall time in ms for the nth solution."""
2720        return _pywrapcp.SolutionCollector_WallTime(self, n)

Returns the wall time in ms for the nth solution.

def Branches(self, n):
2722    def Branches(self, n):
2723        r""" Returns the number of branches when the nth solution was found."""
2724        return _pywrapcp.SolutionCollector_Branches(self, n)

Returns the number of branches when the nth solution was found.

def Failures(self, n):
2726    def Failures(self, n):
2727        r"""
2728        Returns the number of failures encountered at the time of the nth
2729        solution.
2730        """
2731        return _pywrapcp.SolutionCollector_Failures(self, n)

Returns the number of failures encountered at the time of the nth solution.

def ObjectiveValue(self, n):
2733    def ObjectiveValue(self, n):
2734        r""" Returns the objective value of the nth solution."""
2735        return _pywrapcp.SolutionCollector_ObjectiveValue(self, n)

Returns the objective value of the nth solution.

def Value(self, n, var):
2737    def Value(self, n, var):
2738        r""" This is a shortcut to get the Value of 'var' in the nth solution."""
2739        return _pywrapcp.SolutionCollector_Value(self, n, var)

This is a shortcut to get the Value of 'var' in the nth solution.

def StartValue(self, n, var):
2741    def StartValue(self, n, var):
2742        r""" This is a shortcut to get the StartValue of 'var' in the nth solution."""
2743        return _pywrapcp.SolutionCollector_StartValue(self, n, var)

This is a shortcut to get the StartValue of 'var' in the nth solution.

def EndValue(self, n, var):
2745    def EndValue(self, n, var):
2746        r""" This is a shortcut to get the EndValue of 'var' in the nth solution."""
2747        return _pywrapcp.SolutionCollector_EndValue(self, n, var)

This is a shortcut to get the EndValue of 'var' in the nth solution.

def DurationValue(self, n, var):
2749    def DurationValue(self, n, var):
2750        r""" This is a shortcut to get the DurationValue of 'var' in the nth solution."""
2751        return _pywrapcp.SolutionCollector_DurationValue(self, n, var)

This is a shortcut to get the DurationValue of 'var' in the nth solution.

def PerformedValue(self, n, var):
2753    def PerformedValue(self, n, var):
2754        r""" This is a shortcut to get the PerformedValue of 'var' in the nth solution."""
2755        return _pywrapcp.SolutionCollector_PerformedValue(self, n, var)

This is a shortcut to get the PerformedValue of 'var' in the nth solution.

def ForwardSequence(self, n, var):
2757    def ForwardSequence(self, n, var):
2758        r"""
2759        This is a shortcut to get the ForwardSequence of 'var' in the
2760        nth solution. The forward sequence is the list of ranked interval
2761        variables starting from the start of the sequence.
2762        """
2763        return _pywrapcp.SolutionCollector_ForwardSequence(self, n, var)

This is a shortcut to get the ForwardSequence of 'var' in the nth solution. The forward sequence is the list of ranked interval variables starting from the start of the sequence.

def BackwardSequence(self, n, var):
2765    def BackwardSequence(self, n, var):
2766        r"""
2767        This is a shortcut to get the BackwardSequence of 'var' in the
2768        nth solution. The backward sequence is the list of ranked interval
2769        variables starting from the end of the sequence.
2770        """
2771        return _pywrapcp.SolutionCollector_BackwardSequence(self, n, var)

This is a shortcut to get the BackwardSequence of 'var' in the nth solution. The backward sequence is the list of ranked interval variables starting from the end of the sequence.

def Unperformed(self, n, var):
2773    def Unperformed(self, n, var):
2774        r"""
2775        This is a shortcut to get the list of unperformed of 'var' in the
2776        nth solution.
2777        """
2778        return _pywrapcp.SolutionCollector_Unperformed(self, n, var)

This is a shortcut to get the list of unperformed of 'var' in the nth solution.

class OptimizeVar:
2782class OptimizeVar(object):
2783    r"""
2784    This class encapsulates an objective. It requires the direction
2785    (minimize or maximize), the variable to optimize, and the
2786    improvement step.
2787    """
2788
2789    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2790
2791    def __init__(self, *args, **kwargs):
2792        raise AttributeError("No constructor defined")
2793    __repr__ = _swig_repr
2794
2795    def Best(self):
2796        r""" Returns the best value found during search."""
2797        return _pywrapcp.OptimizeVar_Best(self)
2798
2799    def AcceptDelta(self, delta, deltadelta):
2800        r""" Internal methods."""
2801        return _pywrapcp.OptimizeVar_AcceptDelta(self, delta, deltadelta)
2802
2803    def BeginNextDecision(self, db):
2804        return _pywrapcp.OptimizeVar_BeginNextDecision(self, db)
2805
2806    def RefuteDecision(self, d):
2807        return _pywrapcp.OptimizeVar_RefuteDecision(self, d)
2808
2809    def AtSolution(self):
2810        return _pywrapcp.OptimizeVar_AtSolution(self)
2811
2812    def AcceptSolution(self):
2813        return _pywrapcp.OptimizeVar_AcceptSolution(self)
2814
2815    def DebugString(self):
2816        return _pywrapcp.OptimizeVar_DebugString(self)
2817    __swig_destroy__ = _pywrapcp.delete_OptimizeVar

This class encapsulates an objective. It requires the direction (minimize or maximize), the variable to optimize, and the improvement step.

OptimizeVar(*args, **kwargs)
2791    def __init__(self, *args, **kwargs):
2792        raise AttributeError("No constructor defined")
thisown

The membership flag

def Best(self):
2795    def Best(self):
2796        r""" Returns the best value found during search."""
2797        return _pywrapcp.OptimizeVar_Best(self)

Returns the best value found during search.

def AcceptDelta(self, delta, deltadelta):
2799    def AcceptDelta(self, delta, deltadelta):
2800        r""" Internal methods."""
2801        return _pywrapcp.OptimizeVar_AcceptDelta(self, delta, deltadelta)

Internal methods.

def BeginNextDecision(self, db):
2803    def BeginNextDecision(self, db):
2804        return _pywrapcp.OptimizeVar_BeginNextDecision(self, db)
def RefuteDecision(self, d):
2806    def RefuteDecision(self, d):
2807        return _pywrapcp.OptimizeVar_RefuteDecision(self, d)
def AtSolution(self):
2809    def AtSolution(self):
2810        return _pywrapcp.OptimizeVar_AtSolution(self)
def AcceptSolution(self):
2812    def AcceptSolution(self):
2813        return _pywrapcp.OptimizeVar_AcceptSolution(self)
def DebugString(self):
2815    def DebugString(self):
2816        return _pywrapcp.OptimizeVar_DebugString(self)
class SearchLimit(SearchMonitor):
2821class SearchLimit(SearchMonitor):
2822    r""" Base class of all search limits."""
2823
2824    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2825
2826    def __init__(self, *args, **kwargs):
2827        raise AttributeError("No constructor defined - class is abstract")
2828    __repr__ = _swig_repr
2829    __swig_destroy__ = _pywrapcp.delete_SearchLimit
2830
2831    def Crossed(self):
2832        r""" Returns true if the limit has been crossed."""
2833        return _pywrapcp.SearchLimit_Crossed(self)
2834
2835    def Check(self):
2836        r"""
2837        This method is called to check the status of the limit. A return
2838        value of true indicates that we have indeed crossed the limit. In
2839        that case, this method will not be called again and the remaining
2840        search will be discarded.
2841        """
2842        return _pywrapcp.SearchLimit_Check(self)
2843
2844    def Init(self):
2845        r""" This method is called when the search limit is initialized."""
2846        return _pywrapcp.SearchLimit_Init(self)
2847
2848    def EnterSearch(self):
2849        r""" Internal methods."""
2850        return _pywrapcp.SearchLimit_EnterSearch(self)
2851
2852    def BeginNextDecision(self, b):
2853        return _pywrapcp.SearchLimit_BeginNextDecision(self, b)
2854
2855    def RefuteDecision(self, d):
2856        return _pywrapcp.SearchLimit_RefuteDecision(self, d)
2857
2858    def DebugString(self):
2859        return _pywrapcp.SearchLimit_DebugString(self)

Base class of all search limits.

SearchLimit(*args, **kwargs)
2826    def __init__(self, *args, **kwargs):
2827        raise AttributeError("No constructor defined - class is abstract")
thisown

The membership flag

def Crossed(self):
2831    def Crossed(self):
2832        r""" Returns true if the limit has been crossed."""
2833        return _pywrapcp.SearchLimit_Crossed(self)

Returns true if the limit has been crossed.

def Check(self):
2835    def Check(self):
2836        r"""
2837        This method is called to check the status of the limit. A return
2838        value of true indicates that we have indeed crossed the limit. In
2839        that case, this method will not be called again and the remaining
2840        search will be discarded.
2841        """
2842        return _pywrapcp.SearchLimit_Check(self)

This method is called to check the status of the limit. A return value of true indicates that we have indeed crossed the limit. In that case, this method will not be called again and the remaining search will be discarded.

def Init(self):
2844    def Init(self):
2845        r""" This method is called when the search limit is initialized."""
2846        return _pywrapcp.SearchLimit_Init(self)

This method is called when the search limit is initialized.

def EnterSearch(self):
2848    def EnterSearch(self):
2849        r""" Internal methods."""
2850        return _pywrapcp.SearchLimit_EnterSearch(self)

Internal methods.

def BeginNextDecision(self, b):
2852    def BeginNextDecision(self, b):
2853        return _pywrapcp.SearchLimit_BeginNextDecision(self, b)

Before calling DecisionBuilder::Next.

def RefuteDecision(self, d):
2855    def RefuteDecision(self, d):
2856        return _pywrapcp.SearchLimit_RefuteDecision(self, d)

Before refuting the decision.

def DebugString(self):
2858    def DebugString(self):
2859        return _pywrapcp.SearchLimit_DebugString(self)
class IntervalVar(PropagationBaseObject):
2863class IntervalVar(PropagationBaseObject):
2864    r"""
2865    Interval variables are often used in scheduling. The main characteristics
2866    of an IntervalVar are the start position, duration, and end
2867    date. All these characteristics can be queried and set, and demons can
2868    be posted on their modifications.
2869
2870    An important aspect is optionality: an IntervalVar can be performed or not.
2871    If unperformed, then it simply does not exist, and its characteristics
2872    cannot be accessed any more. An interval var is automatically marked
2873    as unperformed when it is not consistent anymore (start greater
2874    than end, duration < 0...)
2875    """
2876
2877    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2878
2879    def __init__(self, *args, **kwargs):
2880        raise AttributeError("No constructor defined - class is abstract")
2881
2882    def StartMin(self):
2883        r"""
2884        These methods query, set, and watch the start position of the
2885        interval var.
2886        """
2887        return _pywrapcp.IntervalVar_StartMin(self)
2888
2889    def StartMax(self):
2890        return _pywrapcp.IntervalVar_StartMax(self)
2891
2892    def SetStartMin(self, m):
2893        return _pywrapcp.IntervalVar_SetStartMin(self, m)
2894
2895    def SetStartMax(self, m):
2896        return _pywrapcp.IntervalVar_SetStartMax(self, m)
2897
2898    def SetStartRange(self, mi, ma):
2899        return _pywrapcp.IntervalVar_SetStartRange(self, mi, ma)
2900
2901    def OldStartMin(self):
2902        return _pywrapcp.IntervalVar_OldStartMin(self)
2903
2904    def OldStartMax(self):
2905        return _pywrapcp.IntervalVar_OldStartMax(self)
2906
2907    def WhenStartRange(self, *args):
2908        return _pywrapcp.IntervalVar_WhenStartRange(self, *args)
2909
2910    def WhenStartBound(self, *args):
2911        return _pywrapcp.IntervalVar_WhenStartBound(self, *args)
2912
2913    def DurationMin(self):
2914        r""" These methods query, set, and watch the duration of the interval var."""
2915        return _pywrapcp.IntervalVar_DurationMin(self)
2916
2917    def DurationMax(self):
2918        return _pywrapcp.IntervalVar_DurationMax(self)
2919
2920    def SetDurationMin(self, m):
2921        return _pywrapcp.IntervalVar_SetDurationMin(self, m)
2922
2923    def SetDurationMax(self, m):
2924        return _pywrapcp.IntervalVar_SetDurationMax(self, m)
2925
2926    def SetDurationRange(self, mi, ma):
2927        return _pywrapcp.IntervalVar_SetDurationRange(self, mi, ma)
2928
2929    def OldDurationMin(self):
2930        return _pywrapcp.IntervalVar_OldDurationMin(self)
2931
2932    def OldDurationMax(self):
2933        return _pywrapcp.IntervalVar_OldDurationMax(self)
2934
2935    def WhenDurationRange(self, *args):
2936        return _pywrapcp.IntervalVar_WhenDurationRange(self, *args)
2937
2938    def WhenDurationBound(self, *args):
2939        return _pywrapcp.IntervalVar_WhenDurationBound(self, *args)
2940
2941    def EndMin(self):
2942        r""" These methods query, set, and watch the end position of the interval var."""
2943        return _pywrapcp.IntervalVar_EndMin(self)
2944
2945    def EndMax(self):
2946        return _pywrapcp.IntervalVar_EndMax(self)
2947
2948    def SetEndMin(self, m):
2949        return _pywrapcp.IntervalVar_SetEndMin(self, m)
2950
2951    def SetEndMax(self, m):
2952        return _pywrapcp.IntervalVar_SetEndMax(self, m)
2953
2954    def SetEndRange(self, mi, ma):
2955        return _pywrapcp.IntervalVar_SetEndRange(self, mi, ma)
2956
2957    def OldEndMin(self):
2958        return _pywrapcp.IntervalVar_OldEndMin(self)
2959
2960    def OldEndMax(self):
2961        return _pywrapcp.IntervalVar_OldEndMax(self)
2962
2963    def WhenEndRange(self, *args):
2964        return _pywrapcp.IntervalVar_WhenEndRange(self, *args)
2965
2966    def WhenEndBound(self, *args):
2967        return _pywrapcp.IntervalVar_WhenEndBound(self, *args)
2968
2969    def MustBePerformed(self):
2970        r"""
2971        These methods query, set, and watch the performed status of the
2972        interval var.
2973        """
2974        return _pywrapcp.IntervalVar_MustBePerformed(self)
2975
2976    def MayBePerformed(self):
2977        return _pywrapcp.IntervalVar_MayBePerformed(self)
2978
2979    def CannotBePerformed(self):
2980        return _pywrapcp.IntervalVar_CannotBePerformed(self)
2981
2982    def IsPerformedBound(self):
2983        return _pywrapcp.IntervalVar_IsPerformedBound(self)
2984
2985    def SetPerformed(self, val):
2986        return _pywrapcp.IntervalVar_SetPerformed(self, val)
2987
2988    def WasPerformedBound(self):
2989        return _pywrapcp.IntervalVar_WasPerformedBound(self)
2990
2991    def WhenPerformedBound(self, *args):
2992        return _pywrapcp.IntervalVar_WhenPerformedBound(self, *args)
2993
2994    def WhenAnything(self, *args):
2995        r"""
2996        *Overload 1:*
2997        Attaches a demon awakened when anything about this interval changes.
2998
2999        |
3000
3001        *Overload 2:*
3002        Attaches a closure awakened when anything about this interval changes.
3003        """
3004        return _pywrapcp.IntervalVar_WhenAnything(self, *args)
3005
3006    def StartExpr(self):
3007        r"""
3008        These methods create expressions encapsulating the start, end
3009        and duration of the interval var. Please note that these must not
3010        be used if the interval var is unperformed.
3011        """
3012        return _pywrapcp.IntervalVar_StartExpr(self)
3013
3014    def DurationExpr(self):
3015        return _pywrapcp.IntervalVar_DurationExpr(self)
3016
3017    def EndExpr(self):
3018        return _pywrapcp.IntervalVar_EndExpr(self)
3019
3020    def PerformedExpr(self):
3021        return _pywrapcp.IntervalVar_PerformedExpr(self)
3022
3023    def SafeStartExpr(self, unperformed_value):
3024        r"""
3025        These methods create expressions encapsulating the start, end
3026        and duration of the interval var. If the interval var is
3027        unperformed, they will return the unperformed_value.
3028        """
3029        return _pywrapcp.IntervalVar_SafeStartExpr(self, unperformed_value)
3030
3031    def SafeDurationExpr(self, unperformed_value):
3032        return _pywrapcp.IntervalVar_SafeDurationExpr(self, unperformed_value)
3033
3034    def SafeEndExpr(self, unperformed_value):
3035        return _pywrapcp.IntervalVar_SafeEndExpr(self, unperformed_value)
3036
3037    def EndsAfterEnd(self, other):
3038        return _pywrapcp.IntervalVar_EndsAfterEnd(self, other)
3039
3040    def EndsAfterEndWithDelay(self, other, delay):
3041        return _pywrapcp.IntervalVar_EndsAfterEndWithDelay(self, other, delay)
3042
3043    def EndsAfterStart(self, other):
3044        return _pywrapcp.IntervalVar_EndsAfterStart(self, other)
3045
3046    def EndsAfterStartWithDelay(self, other, delay):
3047        return _pywrapcp.IntervalVar_EndsAfterStartWithDelay(self, other, delay)
3048
3049    def EndsAtEnd(self, other):
3050        return _pywrapcp.IntervalVar_EndsAtEnd(self, other)
3051
3052    def EndsAtEndWithDelay(self, other, delay):
3053        return _pywrapcp.IntervalVar_EndsAtEndWithDelay(self, other, delay)
3054
3055    def EndsAtStart(self, other):
3056        return _pywrapcp.IntervalVar_EndsAtStart(self, other)
3057
3058    def EndsAtStartWithDelay(self, other, delay):
3059        return _pywrapcp.IntervalVar_EndsAtStartWithDelay(self, other, delay)
3060
3061    def StartsAfterEnd(self, other):
3062        return _pywrapcp.IntervalVar_StartsAfterEnd(self, other)
3063
3064    def StartsAfterEndWithDelay(self, other, delay):
3065        return _pywrapcp.IntervalVar_StartsAfterEndWithDelay(self, other, delay)
3066
3067    def StartsAfterStart(self, other):
3068        return _pywrapcp.IntervalVar_StartsAfterStart(self, other)
3069
3070    def StartsAfterStartWithDelay(self, other, delay):
3071        return _pywrapcp.IntervalVar_StartsAfterStartWithDelay(self, other, delay)
3072
3073    def StartsAtEnd(self, other):
3074        return _pywrapcp.IntervalVar_StartsAtEnd(self, other)
3075
3076    def StartsAtEndWithDelay(self, other, delay):
3077        return _pywrapcp.IntervalVar_StartsAtEndWithDelay(self, other, delay)
3078
3079    def StartsAtStart(self, other):
3080        return _pywrapcp.IntervalVar_StartsAtStart(self, other)
3081
3082    def StartsAtStartWithDelay(self, other, delay):
3083        return _pywrapcp.IntervalVar_StartsAtStartWithDelay(self, other, delay)
3084
3085    def StaysInSync(self, other):
3086        return _pywrapcp.IntervalVar_StaysInSync(self, other)
3087
3088    def StaysInSyncWithDelay(self, other, delay):
3089        return _pywrapcp.IntervalVar_StaysInSyncWithDelay(self, other, delay)
3090
3091    def EndsAfter(self, date):
3092        return _pywrapcp.IntervalVar_EndsAfter(self, date)
3093
3094    def EndsAt(self, date):
3095        return _pywrapcp.IntervalVar_EndsAt(self, date)
3096
3097    def EndsBefore(self, date):
3098        return _pywrapcp.IntervalVar_EndsBefore(self, date)
3099
3100    def StartsAfter(self, date):
3101        return _pywrapcp.IntervalVar_StartsAfter(self, date)
3102
3103    def StartsAt(self, date):
3104        return _pywrapcp.IntervalVar_StartsAt(self, date)
3105
3106    def StartsBefore(self, date):
3107        return _pywrapcp.IntervalVar_StartsBefore(self, date)
3108
3109    def CrossesDate(self, date):
3110        return _pywrapcp.IntervalVar_CrossesDate(self, date)
3111
3112    def AvoidsDate(self, date):
3113        return _pywrapcp.IntervalVar_AvoidsDate(self, date)
3114
3115    def __repr__(self):
3116        return _pywrapcp.IntervalVar___repr__(self)
3117
3118    def __str__(self):
3119        return _pywrapcp.IntervalVar___str__(self)

Interval variables are often used in scheduling. The main characteristics of an IntervalVar are the start position, duration, and end date. All these characteristics can be queried and set, and demons can be posted on their modifications.

An important aspect is optionality: an IntervalVar can be performed or not. If unperformed, then it simply does not exist, and its characteristics cannot be accessed any more. An interval var is automatically marked as unperformed when it is not consistent anymore (start greater than end, duration < 0...)

IntervalVar(*args, **kwargs)
2879    def __init__(self, *args, **kwargs):
2880        raise AttributeError("No constructor defined - class is abstract")
thisown

The membership flag

def StartMin(self):
2882    def StartMin(self):
2883        r"""
2884        These methods query, set, and watch the start position of the
2885        interval var.
2886        """
2887        return _pywrapcp.IntervalVar_StartMin(self)

These methods query, set, and watch the start position of the interval var.

def StartMax(self):
2889    def StartMax(self):
2890        return _pywrapcp.IntervalVar_StartMax(self)
def SetStartMin(self, m):
2892    def SetStartMin(self, m):
2893        return _pywrapcp.IntervalVar_SetStartMin(self, m)
def SetStartMax(self, m):
2895    def SetStartMax(self, m):
2896        return _pywrapcp.IntervalVar_SetStartMax(self, m)
def SetStartRange(self, mi, ma):
2898    def SetStartRange(self, mi, ma):
2899        return _pywrapcp.IntervalVar_SetStartRange(self, mi, ma)
def OldStartMin(self):
2901    def OldStartMin(self):
2902        return _pywrapcp.IntervalVar_OldStartMin(self)
def OldStartMax(self):
2904    def OldStartMax(self):
2905        return _pywrapcp.IntervalVar_OldStartMax(self)
def WhenStartRange(self, *args):
2907    def WhenStartRange(self, *args):
2908        return _pywrapcp.IntervalVar_WhenStartRange(self, *args)
def WhenStartBound(self, *args):
2910    def WhenStartBound(self, *args):
2911        return _pywrapcp.IntervalVar_WhenStartBound(self, *args)
def DurationMin(self):
2913    def DurationMin(self):
2914        r""" These methods query, set, and watch the duration of the interval var."""
2915        return _pywrapcp.IntervalVar_DurationMin(self)

These methods query, set, and watch the duration of the interval var.

def DurationMax(self):
2917    def DurationMax(self):
2918        return _pywrapcp.IntervalVar_DurationMax(self)
def SetDurationMin(self, m):
2920    def SetDurationMin(self, m):
2921        return _pywrapcp.IntervalVar_SetDurationMin(self, m)
def SetDurationMax(self, m):
2923    def SetDurationMax(self, m):
2924        return _pywrapcp.IntervalVar_SetDurationMax(self, m)
def SetDurationRange(self, mi, ma):
2926    def SetDurationRange(self, mi, ma):
2927        return _pywrapcp.IntervalVar_SetDurationRange(self, mi, ma)
def OldDurationMin(self):
2929    def OldDurationMin(self):
2930        return _pywrapcp.IntervalVar_OldDurationMin(self)
def OldDurationMax(self):
2932    def OldDurationMax(self):
2933        return _pywrapcp.IntervalVar_OldDurationMax(self)
def WhenDurationRange(self, *args):
2935    def WhenDurationRange(self, *args):
2936        return _pywrapcp.IntervalVar_WhenDurationRange(self, *args)
def WhenDurationBound(self, *args):
2938    def WhenDurationBound(self, *args):
2939        return _pywrapcp.IntervalVar_WhenDurationBound(self, *args)
def EndMin(self):
2941    def EndMin(self):
2942        r""" These methods query, set, and watch the end position of the interval var."""
2943        return _pywrapcp.IntervalVar_EndMin(self)

These methods query, set, and watch the end position of the interval var.

def EndMax(self):
2945    def EndMax(self):
2946        return _pywrapcp.IntervalVar_EndMax(self)
def SetEndMin(self, m):
2948    def SetEndMin(self, m):
2949        return _pywrapcp.IntervalVar_SetEndMin(self, m)
def SetEndMax(self, m):
2951    def SetEndMax(self, m):
2952        return _pywrapcp.IntervalVar_SetEndMax(self, m)
def SetEndRange(self, mi, ma):
2954    def SetEndRange(self, mi, ma):
2955        return _pywrapcp.IntervalVar_SetEndRange(self, mi, ma)
def OldEndMin(self):
2957    def OldEndMin(self):
2958        return _pywrapcp.IntervalVar_OldEndMin(self)
def OldEndMax(self):
2960    def OldEndMax(self):
2961        return _pywrapcp.IntervalVar_OldEndMax(self)
def WhenEndRange(self, *args):
2963    def WhenEndRange(self, *args):
2964        return _pywrapcp.IntervalVar_WhenEndRange(self, *args)
def WhenEndBound(self, *args):
2966    def WhenEndBound(self, *args):
2967        return _pywrapcp.IntervalVar_WhenEndBound(self, *args)
def MustBePerformed(self):
2969    def MustBePerformed(self):
2970        r"""
2971        These methods query, set, and watch the performed status of the
2972        interval var.
2973        """
2974        return _pywrapcp.IntervalVar_MustBePerformed(self)

These methods query, set, and watch the performed status of the interval var.

def MayBePerformed(self):
2976    def MayBePerformed(self):
2977        return _pywrapcp.IntervalVar_MayBePerformed(self)
def CannotBePerformed(self):
2979    def CannotBePerformed(self):
2980        return _pywrapcp.IntervalVar_CannotBePerformed(self)
def IsPerformedBound(self):
2982    def IsPerformedBound(self):
2983        return _pywrapcp.IntervalVar_IsPerformedBound(self)
def SetPerformed(self, val):
2985    def SetPerformed(self, val):
2986        return _pywrapcp.IntervalVar_SetPerformed(self, val)
def WasPerformedBound(self):
2988    def WasPerformedBound(self):
2989        return _pywrapcp.IntervalVar_WasPerformedBound(self)
def WhenPerformedBound(self, *args):
2991    def WhenPerformedBound(self, *args):
2992        return _pywrapcp.IntervalVar_WhenPerformedBound(self, *args)
def WhenAnything(self, *args):
2994    def WhenAnything(self, *args):
2995        r"""
2996        *Overload 1:*
2997        Attaches a demon awakened when anything about this interval changes.
2998
2999        |
3000
3001        *Overload 2:*
3002        Attaches a closure awakened when anything about this interval changes.
3003        """
3004        return _pywrapcp.IntervalVar_WhenAnything(self, *args)

Overload 1: Attaches a demon awakened when anything about this interval changes.

|

Overload 2: Attaches a closure awakened when anything about this interval changes.

def StartExpr(self):
3006    def StartExpr(self):
3007        r"""
3008        These methods create expressions encapsulating the start, end
3009        and duration of the interval var. Please note that these must not
3010        be used if the interval var is unperformed.
3011        """
3012        return _pywrapcp.IntervalVar_StartExpr(self)

These methods create expressions encapsulating the start, end and duration of the interval var. Please note that these must not be used if the interval var is unperformed.

def DurationExpr(self):
3014    def DurationExpr(self):
3015        return _pywrapcp.IntervalVar_DurationExpr(self)
def EndExpr(self):
3017    def EndExpr(self):
3018        return _pywrapcp.IntervalVar_EndExpr(self)
def PerformedExpr(self):
3020    def PerformedExpr(self):
3021        return _pywrapcp.IntervalVar_PerformedExpr(self)
def SafeStartExpr(self, unperformed_value):
3023    def SafeStartExpr(self, unperformed_value):
3024        r"""
3025        These methods create expressions encapsulating the start, end
3026        and duration of the interval var. If the interval var is
3027        unperformed, they will return the unperformed_value.
3028        """
3029        return _pywrapcp.IntervalVar_SafeStartExpr(self, unperformed_value)

These methods create expressions encapsulating the start, end and duration of the interval var. If the interval var is unperformed, they will return the unperformed_value.

def SafeDurationExpr(self, unperformed_value):
3031    def SafeDurationExpr(self, unperformed_value):
3032        return _pywrapcp.IntervalVar_SafeDurationExpr(self, unperformed_value)
def SafeEndExpr(self, unperformed_value):
3034    def SafeEndExpr(self, unperformed_value):
3035        return _pywrapcp.IntervalVar_SafeEndExpr(self, unperformed_value)
def EndsAfterEnd(self, other):
3037    def EndsAfterEnd(self, other):
3038        return _pywrapcp.IntervalVar_EndsAfterEnd(self, other)
def EndsAfterEndWithDelay(self, other, delay):
3040    def EndsAfterEndWithDelay(self, other, delay):
3041        return _pywrapcp.IntervalVar_EndsAfterEndWithDelay(self, other, delay)
def EndsAfterStart(self, other):
3043    def EndsAfterStart(self, other):
3044        return _pywrapcp.IntervalVar_EndsAfterStart(self, other)
def EndsAfterStartWithDelay(self, other, delay):
3046    def EndsAfterStartWithDelay(self, other, delay):
3047        return _pywrapcp.IntervalVar_EndsAfterStartWithDelay(self, other, delay)
def EndsAtEnd(self, other):
3049    def EndsAtEnd(self, other):
3050        return _pywrapcp.IntervalVar_EndsAtEnd(self, other)
def EndsAtEndWithDelay(self, other, delay):
3052    def EndsAtEndWithDelay(self, other, delay):
3053        return _pywrapcp.IntervalVar_EndsAtEndWithDelay(self, other, delay)
def EndsAtStart(self, other):
3055    def EndsAtStart(self, other):
3056        return _pywrapcp.IntervalVar_EndsAtStart(self, other)
def EndsAtStartWithDelay(self, other, delay):
3058    def EndsAtStartWithDelay(self, other, delay):
3059        return _pywrapcp.IntervalVar_EndsAtStartWithDelay(self, other, delay)
def StartsAfterEnd(self, other):
3061    def StartsAfterEnd(self, other):
3062        return _pywrapcp.IntervalVar_StartsAfterEnd(self, other)
def StartsAfterEndWithDelay(self, other, delay):
3064    def StartsAfterEndWithDelay(self, other, delay):
3065        return _pywrapcp.IntervalVar_StartsAfterEndWithDelay(self, other, delay)
def StartsAfterStart(self, other):
3067    def StartsAfterStart(self, other):
3068        return _pywrapcp.IntervalVar_StartsAfterStart(self, other)
def StartsAfterStartWithDelay(self, other, delay):
3070    def StartsAfterStartWithDelay(self, other, delay):
3071        return _pywrapcp.IntervalVar_StartsAfterStartWithDelay(self, other, delay)
def StartsAtEnd(self, other):
3073    def StartsAtEnd(self, other):
3074        return _pywrapcp.IntervalVar_StartsAtEnd(self, other)
def StartsAtEndWithDelay(self, other, delay):
3076    def StartsAtEndWithDelay(self, other, delay):
3077        return _pywrapcp.IntervalVar_StartsAtEndWithDelay(self, other, delay)
def StartsAtStart(self, other):
3079    def StartsAtStart(self, other):
3080        return _pywrapcp.IntervalVar_StartsAtStart(self, other)
def StartsAtStartWithDelay(self, other, delay):
3082    def StartsAtStartWithDelay(self, other, delay):
3083        return _pywrapcp.IntervalVar_StartsAtStartWithDelay(self, other, delay)
def StaysInSync(self, other):
3085    def StaysInSync(self, other):
3086        return _pywrapcp.IntervalVar_StaysInSync(self, other)
def StaysInSyncWithDelay(self, other, delay):
3088    def StaysInSyncWithDelay(self, other, delay):
3089        return _pywrapcp.IntervalVar_StaysInSyncWithDelay(self, other, delay)
def EndsAfter(self, date):
3091    def EndsAfter(self, date):
3092        return _pywrapcp.IntervalVar_EndsAfter(self, date)
def EndsAt(self, date):
3094    def EndsAt(self, date):
3095        return _pywrapcp.IntervalVar_EndsAt(self, date)
def EndsBefore(self, date):
3097    def EndsBefore(self, date):
3098        return _pywrapcp.IntervalVar_EndsBefore(self, date)
def StartsAfter(self, date):
3100    def StartsAfter(self, date):
3101        return _pywrapcp.IntervalVar_StartsAfter(self, date)
def StartsAt(self, date):
3103    def StartsAt(self, date):
3104        return _pywrapcp.IntervalVar_StartsAt(self, date)
def StartsBefore(self, date):
3106    def StartsBefore(self, date):
3107        return _pywrapcp.IntervalVar_StartsBefore(self, date)
def CrossesDate(self, date):
3109    def CrossesDate(self, date):
3110        return _pywrapcp.IntervalVar_CrossesDate(self, date)
def AvoidsDate(self, date):
3112    def AvoidsDate(self, date):
3113        return _pywrapcp.IntervalVar_AvoidsDate(self, date)
class SequenceVar(PropagationBaseObject):
3123class SequenceVar(PropagationBaseObject):
3124    r"""
3125    A sequence variable is a variable whose domain is a set of possible
3126    orderings of the interval variables. It allows ordering of tasks. It
3127    has two sets of methods: ComputePossibleFirstsAndLasts(), which
3128    returns the list of interval variables that can be ranked first or
3129    last; and RankFirst/RankNotFirst/RankLast/RankNotLast, which can be
3130    used to create the search decision.
3131    """
3132
3133    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3134
3135    def __init__(self, *args, **kwargs):
3136        raise AttributeError("No constructor defined")
3137
3138    def DebugString(self):
3139        return _pywrapcp.SequenceVar_DebugString(self)
3140
3141    def RankFirst(self, index):
3142        r"""
3143        Ranks the index_th interval var first of all unranked interval
3144        vars. After that, it will no longer be considered ranked.
3145        """
3146        return _pywrapcp.SequenceVar_RankFirst(self, index)
3147
3148    def RankNotFirst(self, index):
3149        r"""
3150        Indicates that the index_th interval var will not be ranked first
3151        of all currently unranked interval vars.
3152        """
3153        return _pywrapcp.SequenceVar_RankNotFirst(self, index)
3154
3155    def RankLast(self, index):
3156        r"""
3157        Ranks the index_th interval var first of all unranked interval
3158        vars. After that, it will no longer be considered ranked.
3159        """
3160        return _pywrapcp.SequenceVar_RankLast(self, index)
3161
3162    def RankNotLast(self, index):
3163        r"""
3164        Indicates that the index_th interval var will not be ranked first
3165        of all currently unranked interval vars.
3166        """
3167        return _pywrapcp.SequenceVar_RankNotLast(self, index)
3168
3169    def Interval(self, index):
3170        r""" Returns the index_th interval of the sequence."""
3171        return _pywrapcp.SequenceVar_Interval(self, index)
3172
3173    def Next(self, index):
3174        r""" Returns the next of the index_th interval of the sequence."""
3175        return _pywrapcp.SequenceVar_Next(self, index)
3176
3177    def Size(self):
3178        r""" Returns the number of interval vars in the sequence."""
3179        return _pywrapcp.SequenceVar_Size(self)
3180
3181    def __repr__(self):
3182        return _pywrapcp.SequenceVar___repr__(self)
3183
3184    def __str__(self):
3185        return _pywrapcp.SequenceVar___str__(self)

A sequence variable is a variable whose domain is a set of possible orderings of the interval variables. It allows ordering of tasks. It has two sets of methods: ComputePossibleFirstsAndLasts(), which returns the list of interval variables that can be ranked first or last; and RankFirst/RankNotFirst/RankLast/RankNotLast, which can be used to create the search decision.

SequenceVar(*args, **kwargs)
3135    def __init__(self, *args, **kwargs):
3136        raise AttributeError("No constructor defined")
thisown

The membership flag

def DebugString(self):
3138    def DebugString(self):
3139        return _pywrapcp.SequenceVar_DebugString(self)
def RankFirst(self, index):
3141    def RankFirst(self, index):
3142        r"""
3143        Ranks the index_th interval var first of all unranked interval
3144        vars. After that, it will no longer be considered ranked.
3145        """
3146        return _pywrapcp.SequenceVar_RankFirst(self, index)

Ranks the index_th interval var first of all unranked interval vars. After that, it will no longer be considered ranked.

def RankNotFirst(self, index):
3148    def RankNotFirst(self, index):
3149        r"""
3150        Indicates that the index_th interval var will not be ranked first
3151        of all currently unranked interval vars.
3152        """
3153        return _pywrapcp.SequenceVar_RankNotFirst(self, index)

Indicates that the index_th interval var will not be ranked first of all currently unranked interval vars.

def RankLast(self, index):
3155    def RankLast(self, index):
3156        r"""
3157        Ranks the index_th interval var first of all unranked interval
3158        vars. After that, it will no longer be considered ranked.
3159        """
3160        return _pywrapcp.SequenceVar_RankLast(self, index)

Ranks the index_th interval var first of all unranked interval vars. After that, it will no longer be considered ranked.

def RankNotLast(self, index):
3162    def RankNotLast(self, index):
3163        r"""
3164        Indicates that the index_th interval var will not be ranked first
3165        of all currently unranked interval vars.
3166        """
3167        return _pywrapcp.SequenceVar_RankNotLast(self, index)

Indicates that the index_th interval var will not be ranked first of all currently unranked interval vars.

def Interval(self, index):
3169    def Interval(self, index):
3170        r""" Returns the index_th interval of the sequence."""
3171        return _pywrapcp.SequenceVar_Interval(self, index)

Returns the index_th interval of the sequence.

def Next(self, index):
3173    def Next(self, index):
3174        r""" Returns the next of the index_th interval of the sequence."""
3175        return _pywrapcp.SequenceVar_Next(self, index)

Returns the next of the index_th interval of the sequence.

def Size(self):
3177    def Size(self):
3178        r""" Returns the number of interval vars in the sequence."""
3179        return _pywrapcp.SequenceVar_Size(self)

Returns the number of interval vars in the sequence.

Inherited Members
PropagationBaseObject
solver
Name
class AssignmentElement:
3189class AssignmentElement(object):
3190    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3191
3192    def __init__(self, *args, **kwargs):
3193        raise AttributeError("No constructor defined")
3194    __repr__ = _swig_repr
3195
3196    def Activate(self):
3197        return _pywrapcp.AssignmentElement_Activate(self)
3198
3199    def Deactivate(self):
3200        return _pywrapcp.AssignmentElement_Deactivate(self)
3201
3202    def Activated(self):
3203        return _pywrapcp.AssignmentElement_Activated(self)
3204    __swig_destroy__ = _pywrapcp.delete_AssignmentElement
AssignmentElement(*args, **kwargs)
3192    def __init__(self, *args, **kwargs):
3193        raise AttributeError("No constructor defined")
thisown

The membership flag

def Activate(self):
3196    def Activate(self):
3197        return _pywrapcp.AssignmentElement_Activate(self)
def Deactivate(self):
3199    def Deactivate(self):
3200        return _pywrapcp.AssignmentElement_Deactivate(self)
def Activated(self):
3202    def Activated(self):
3203        return _pywrapcp.AssignmentElement_Activated(self)
class IntVarElement(AssignmentElement):
3208class IntVarElement(AssignmentElement):
3209    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3210
3211    def __init__(self, *args, **kwargs):
3212        raise AttributeError("No constructor defined")
3213    __repr__ = _swig_repr
3214
3215    def Var(self):
3216        return _pywrapcp.IntVarElement_Var(self)
3217
3218    def Min(self):
3219        return _pywrapcp.IntVarElement_Min(self)
3220
3221    def SetMin(self, m):
3222        return _pywrapcp.IntVarElement_SetMin(self, m)
3223
3224    def Max(self):
3225        return _pywrapcp.IntVarElement_Max(self)
3226
3227    def SetMax(self, m):
3228        return _pywrapcp.IntVarElement_SetMax(self, m)
3229
3230    def Value(self):
3231        return _pywrapcp.IntVarElement_Value(self)
3232
3233    def Bound(self):
3234        return _pywrapcp.IntVarElement_Bound(self)
3235
3236    def SetRange(self, l, u):
3237        return _pywrapcp.IntVarElement_SetRange(self, l, u)
3238
3239    def SetValue(self, v):
3240        return _pywrapcp.IntVarElement_SetValue(self, v)
3241
3242    def __eq__(self, element):
3243        return _pywrapcp.IntVarElement___eq__(self, element)
3244
3245    def __ne__(self, element):
3246        return _pywrapcp.IntVarElement___ne__(self, element)
3247    __swig_destroy__ = _pywrapcp.delete_IntVarElement
IntVarElement(*args, **kwargs)
3211    def __init__(self, *args, **kwargs):
3212        raise AttributeError("No constructor defined")
thisown

The membership flag

def Var(self):
3215    def Var(self):
3216        return _pywrapcp.IntVarElement_Var(self)
def Min(self):
3218    def Min(self):
3219        return _pywrapcp.IntVarElement_Min(self)
def SetMin(self, m):
3221    def SetMin(self, m):
3222        return _pywrapcp.IntVarElement_SetMin(self, m)
def Max(self):
3224    def Max(self):
3225        return _pywrapcp.IntVarElement_Max(self)
def SetMax(self, m):
3227    def SetMax(self, m):
3228        return _pywrapcp.IntVarElement_SetMax(self, m)
def Value(self):
3230    def Value(self):
3231        return _pywrapcp.IntVarElement_Value(self)
def Bound(self):
3233    def Bound(self):
3234        return _pywrapcp.IntVarElement_Bound(self)
def SetRange(self, l, u):
3236    def SetRange(self, l, u):
3237        return _pywrapcp.IntVarElement_SetRange(self, l, u)
def SetValue(self, v):
3239    def SetValue(self, v):
3240        return _pywrapcp.IntVarElement_SetValue(self, v)
class IntervalVarElement(AssignmentElement):
3251class IntervalVarElement(AssignmentElement):
3252    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3253
3254    def __init__(self, *args, **kwargs):
3255        raise AttributeError("No constructor defined")
3256    __repr__ = _swig_repr
3257
3258    def Var(self):
3259        return _pywrapcp.IntervalVarElement_Var(self)
3260
3261    def StartMin(self):
3262        return _pywrapcp.IntervalVarElement_StartMin(self)
3263
3264    def StartMax(self):
3265        return _pywrapcp.IntervalVarElement_StartMax(self)
3266
3267    def StartValue(self):
3268        return _pywrapcp.IntervalVarElement_StartValue(self)
3269
3270    def DurationMin(self):
3271        return _pywrapcp.IntervalVarElement_DurationMin(self)
3272
3273    def DurationMax(self):
3274        return _pywrapcp.IntervalVarElement_DurationMax(self)
3275
3276    def DurationValue(self):
3277        return _pywrapcp.IntervalVarElement_DurationValue(self)
3278
3279    def EndMin(self):
3280        return _pywrapcp.IntervalVarElement_EndMin(self)
3281
3282    def EndMax(self):
3283        return _pywrapcp.IntervalVarElement_EndMax(self)
3284
3285    def EndValue(self):
3286        return _pywrapcp.IntervalVarElement_EndValue(self)
3287
3288    def PerformedMin(self):
3289        return _pywrapcp.IntervalVarElement_PerformedMin(self)
3290
3291    def PerformedMax(self):
3292        return _pywrapcp.IntervalVarElement_PerformedMax(self)
3293
3294    def PerformedValue(self):
3295        return _pywrapcp.IntervalVarElement_PerformedValue(self)
3296
3297    def SetStartMin(self, m):
3298        return _pywrapcp.IntervalVarElement_SetStartMin(self, m)
3299
3300    def SetStartMax(self, m):
3301        return _pywrapcp.IntervalVarElement_SetStartMax(self, m)
3302
3303    def SetStartRange(self, mi, ma):
3304        return _pywrapcp.IntervalVarElement_SetStartRange(self, mi, ma)
3305
3306    def SetStartValue(self, v):
3307        return _pywrapcp.IntervalVarElement_SetStartValue(self, v)
3308
3309    def SetDurationMin(self, m):
3310        return _pywrapcp.IntervalVarElement_SetDurationMin(self, m)
3311
3312    def SetDurationMax(self, m):
3313        return _pywrapcp.IntervalVarElement_SetDurationMax(self, m)
3314
3315    def SetDurationRange(self, mi, ma):
3316        return _pywrapcp.IntervalVarElement_SetDurationRange(self, mi, ma)
3317
3318    def SetDurationValue(self, v):
3319        return _pywrapcp.IntervalVarElement_SetDurationValue(self, v)
3320
3321    def SetEndMin(self, m):
3322        return _pywrapcp.IntervalVarElement_SetEndMin(self, m)
3323
3324    def SetEndMax(self, m):
3325        return _pywrapcp.IntervalVarElement_SetEndMax(self, m)
3326
3327    def SetEndRange(self, mi, ma):
3328        return _pywrapcp.IntervalVarElement_SetEndRange(self, mi, ma)
3329
3330    def SetEndValue(self, v):
3331        return _pywrapcp.IntervalVarElement_SetEndValue(self, v)
3332
3333    def SetPerformedMin(self, m):
3334        return _pywrapcp.IntervalVarElement_SetPerformedMin(self, m)
3335
3336    def SetPerformedMax(self, m):
3337        return _pywrapcp.IntervalVarElement_SetPerformedMax(self, m)
3338
3339    def SetPerformedRange(self, mi, ma):
3340        return _pywrapcp.IntervalVarElement_SetPerformedRange(self, mi, ma)
3341
3342    def SetPerformedValue(self, v):
3343        return _pywrapcp.IntervalVarElement_SetPerformedValue(self, v)
3344
3345    def __eq__(self, element):
3346        return _pywrapcp.IntervalVarElement___eq__(self, element)
3347
3348    def __ne__(self, element):
3349        return _pywrapcp.IntervalVarElement___ne__(self, element)
3350    __swig_destroy__ = _pywrapcp.delete_IntervalVarElement
IntervalVarElement(*args, **kwargs)
3254    def __init__(self, *args, **kwargs):
3255        raise AttributeError("No constructor defined")
thisown

The membership flag

def Var(self):
3258    def Var(self):
3259        return _pywrapcp.IntervalVarElement_Var(self)
def StartMin(self):
3261    def StartMin(self):
3262        return _pywrapcp.IntervalVarElement_StartMin(self)
def StartMax(self):
3264    def StartMax(self):
3265        return _pywrapcp.IntervalVarElement_StartMax(self)
def StartValue(self):
3267    def StartValue(self):
3268        return _pywrapcp.IntervalVarElement_StartValue(self)
def DurationMin(self):
3270    def DurationMin(self):
3271        return _pywrapcp.IntervalVarElement_DurationMin(self)
def DurationMax(self):
3273    def DurationMax(self):
3274        return _pywrapcp.IntervalVarElement_DurationMax(self)
def DurationValue(self):
3276    def DurationValue(self):
3277        return _pywrapcp.IntervalVarElement_DurationValue(self)
def EndMin(self):
3279    def EndMin(self):
3280        return _pywrapcp.IntervalVarElement_EndMin(self)
def EndMax(self):
3282    def EndMax(self):
3283        return _pywrapcp.IntervalVarElement_EndMax(self)
def EndValue(self):
3285    def EndValue(self):
3286        return _pywrapcp.IntervalVarElement_EndValue(self)
def PerformedMin(self):
3288    def PerformedMin(self):
3289        return _pywrapcp.IntervalVarElement_PerformedMin(self)
def PerformedMax(self):
3291    def PerformedMax(self):
3292        return _pywrapcp.IntervalVarElement_PerformedMax(self)
def PerformedValue(self):
3294    def PerformedValue(self):
3295        return _pywrapcp.IntervalVarElement_PerformedValue(self)
def SetStartMin(self, m):
3297    def SetStartMin(self, m):
3298        return _pywrapcp.IntervalVarElement_SetStartMin(self, m)
def SetStartMax(self, m):
3300    def SetStartMax(self, m):
3301        return _pywrapcp.IntervalVarElement_SetStartMax(self, m)
def SetStartRange(self, mi, ma):
3303    def SetStartRange(self, mi, ma):
3304        return _pywrapcp.IntervalVarElement_SetStartRange(self, mi, ma)
def SetStartValue(self, v):
3306    def SetStartValue(self, v):
3307        return _pywrapcp.IntervalVarElement_SetStartValue(self, v)
def SetDurationMin(self, m):
3309    def SetDurationMin(self, m):
3310        return _pywrapcp.IntervalVarElement_SetDurationMin(self, m)
def SetDurationMax(self, m):
3312    def SetDurationMax(self, m):
3313        return _pywrapcp.IntervalVarElement_SetDurationMax(self, m)
def SetDurationRange(self, mi, ma):
3315    def SetDurationRange(self, mi, ma):
3316        return _pywrapcp.IntervalVarElement_SetDurationRange(self, mi, ma)
def SetDurationValue(self, v):
3318    def SetDurationValue(self, v):
3319        return _pywrapcp.IntervalVarElement_SetDurationValue(self, v)
def SetEndMin(self, m):
3321    def SetEndMin(self, m):
3322        return _pywrapcp.IntervalVarElement_SetEndMin(self, m)
def SetEndMax(self, m):
3324    def SetEndMax(self, m):
3325        return _pywrapcp.IntervalVarElement_SetEndMax(self, m)
def SetEndRange(self, mi, ma):
3327    def SetEndRange(self, mi, ma):
3328        return _pywrapcp.IntervalVarElement_SetEndRange(self, mi, ma)
def SetEndValue(self, v):
3330    def SetEndValue(self, v):
3331        return _pywrapcp.IntervalVarElement_SetEndValue(self, v)
def SetPerformedMin(self, m):
3333    def SetPerformedMin(self, m):
3334        return _pywrapcp.IntervalVarElement_SetPerformedMin(self, m)
def SetPerformedMax(self, m):
3336    def SetPerformedMax(self, m):
3337        return _pywrapcp.IntervalVarElement_SetPerformedMax(self, m)
def SetPerformedRange(self, mi, ma):
3339    def SetPerformedRange(self, mi, ma):
3340        return _pywrapcp.IntervalVarElement_SetPerformedRange(self, mi, ma)
def SetPerformedValue(self, v):
3342    def SetPerformedValue(self, v):
3343        return _pywrapcp.IntervalVarElement_SetPerformedValue(self, v)
class SequenceVarElement(AssignmentElement):
3354class SequenceVarElement(AssignmentElement):
3355    r"""
3356    The SequenceVarElement stores a partial representation of ranked
3357    interval variables in the underlying sequence variable.
3358    This representation consists of three vectors:
3359      - the forward sequence. That is the list of interval variables
3360        ranked first in the sequence.  The first element of the backward
3361        sequence is the first interval in the sequence variable.
3362      - the backward sequence. That is the list of interval variables
3363        ranked last in the sequence. The first element of the backward
3364        sequence is the last interval in the sequence variable.
3365      - The list of unperformed interval variables.
3366     Furthermore, if all performed variables are ranked, then by
3367     convention, the forward_sequence will contain all such variables
3368     and the backward_sequence will be empty.
3369    """
3370
3371    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3372
3373    def __init__(self, *args, **kwargs):
3374        raise AttributeError("No constructor defined")
3375    __repr__ = _swig_repr
3376
3377    def Var(self):
3378        return _pywrapcp.SequenceVarElement_Var(self)
3379
3380    def ForwardSequence(self):
3381        return _pywrapcp.SequenceVarElement_ForwardSequence(self)
3382
3383    def BackwardSequence(self):
3384        return _pywrapcp.SequenceVarElement_BackwardSequence(self)
3385
3386    def Unperformed(self):
3387        return _pywrapcp.SequenceVarElement_Unperformed(self)
3388
3389    def SetSequence(self, forward_sequence, backward_sequence, unperformed):
3390        return _pywrapcp.SequenceVarElement_SetSequence(self, forward_sequence, backward_sequence, unperformed)
3391
3392    def SetForwardSequence(self, forward_sequence):
3393        return _pywrapcp.SequenceVarElement_SetForwardSequence(self, forward_sequence)
3394
3395    def SetBackwardSequence(self, backward_sequence):
3396        return _pywrapcp.SequenceVarElement_SetBackwardSequence(self, backward_sequence)
3397
3398    def SetUnperformed(self, unperformed):
3399        return _pywrapcp.SequenceVarElement_SetUnperformed(self, unperformed)
3400
3401    def __eq__(self, element):
3402        return _pywrapcp.SequenceVarElement___eq__(self, element)
3403
3404    def __ne__(self, element):
3405        return _pywrapcp.SequenceVarElement___ne__(self, element)
3406    __swig_destroy__ = _pywrapcp.delete_SequenceVarElement

The SequenceVarElement stores a partial representation of ranked interval variables in the underlying sequence variable.

This representation consists of three vectors:
  • the forward sequence. That is the list of interval variables ranked first in the sequence. The first element of the backward sequence is the first interval in the sequence variable.
    • the backward sequence. That is the list of interval variables ranked last in the sequence. The first element of the backward sequence is the last interval in the sequence variable.
    • The list of unperformed interval variables. Furthermore, if all performed variables are ranked, then by convention, the forward_sequence will contain all such variables and the backward_sequence will be empty.
SequenceVarElement(*args, **kwargs)
3373    def __init__(self, *args, **kwargs):
3374        raise AttributeError("No constructor defined")
thisown

The membership flag

def Var(self):
3377    def Var(self):
3378        return _pywrapcp.SequenceVarElement_Var(self)
def ForwardSequence(self):
3380    def ForwardSequence(self):
3381        return _pywrapcp.SequenceVarElement_ForwardSequence(self)
def BackwardSequence(self):
3383    def BackwardSequence(self):
3384        return _pywrapcp.SequenceVarElement_BackwardSequence(self)
def Unperformed(self):
3386    def Unperformed(self):
3387        return _pywrapcp.SequenceVarElement_Unperformed(self)
def SetSequence(self, forward_sequence, backward_sequence, unperformed):
3389    def SetSequence(self, forward_sequence, backward_sequence, unperformed):
3390        return _pywrapcp.SequenceVarElement_SetSequence(self, forward_sequence, backward_sequence, unperformed)
def SetForwardSequence(self, forward_sequence):
3392    def SetForwardSequence(self, forward_sequence):
3393        return _pywrapcp.SequenceVarElement_SetForwardSequence(self, forward_sequence)
def SetBackwardSequence(self, backward_sequence):
3395    def SetBackwardSequence(self, backward_sequence):
3396        return _pywrapcp.SequenceVarElement_SetBackwardSequence(self, backward_sequence)
def SetUnperformed(self, unperformed):
3398    def SetUnperformed(self, unperformed):
3399        return _pywrapcp.SequenceVarElement_SetUnperformed(self, unperformed)
class Assignment(PropagationBaseObject):
3410class Assignment(PropagationBaseObject):
3411    r"""
3412    An Assignment is a variable -> domains mapping, used
3413    to report solutions to the user.
3414    """
3415
3416    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3417
3418    def __init__(self, *args, **kwargs):
3419        raise AttributeError("No constructor defined")
3420    __repr__ = _swig_repr
3421
3422    def Clear(self):
3423        return _pywrapcp.Assignment_Clear(self)
3424
3425    def Empty(self):
3426        return _pywrapcp.Assignment_Empty(self)
3427
3428    def Size(self):
3429        return _pywrapcp.Assignment_Size(self)
3430
3431    def NumIntVars(self):
3432        return _pywrapcp.Assignment_NumIntVars(self)
3433
3434    def NumIntervalVars(self):
3435        return _pywrapcp.Assignment_NumIntervalVars(self)
3436
3437    def NumSequenceVars(self):
3438        return _pywrapcp.Assignment_NumSequenceVars(self)
3439
3440    def Store(self):
3441        return _pywrapcp.Assignment_Store(self)
3442
3443    def Restore(self):
3444        return _pywrapcp.Assignment_Restore(self)
3445
3446    def Load(self, *args):
3447        return _pywrapcp.Assignment_Load(self, *args)
3448
3449    def Save(self, *args):
3450        return _pywrapcp.Assignment_Save(self, *args)
3451
3452    def AddObjective(self, v):
3453        return _pywrapcp.Assignment_AddObjective(self, v)
3454
3455    def Objective(self):
3456        return _pywrapcp.Assignment_Objective(self)
3457
3458    def HasObjective(self):
3459        return _pywrapcp.Assignment_HasObjective(self)
3460
3461    def ObjectiveMin(self):
3462        return _pywrapcp.Assignment_ObjectiveMin(self)
3463
3464    def ObjectiveMax(self):
3465        return _pywrapcp.Assignment_ObjectiveMax(self)
3466
3467    def ObjectiveValue(self):
3468        return _pywrapcp.Assignment_ObjectiveValue(self)
3469
3470    def ObjectiveBound(self):
3471        return _pywrapcp.Assignment_ObjectiveBound(self)
3472
3473    def SetObjectiveMin(self, m):
3474        return _pywrapcp.Assignment_SetObjectiveMin(self, m)
3475
3476    def SetObjectiveMax(self, m):
3477        return _pywrapcp.Assignment_SetObjectiveMax(self, m)
3478
3479    def SetObjectiveValue(self, value):
3480        return _pywrapcp.Assignment_SetObjectiveValue(self, value)
3481
3482    def SetObjectiveRange(self, l, u):
3483        return _pywrapcp.Assignment_SetObjectiveRange(self, l, u)
3484
3485    def Min(self, var):
3486        return _pywrapcp.Assignment_Min(self, var)
3487
3488    def Max(self, var):
3489        return _pywrapcp.Assignment_Max(self, var)
3490
3491    def Value(self, var):
3492        return _pywrapcp.Assignment_Value(self, var)
3493
3494    def Bound(self, var):
3495        return _pywrapcp.Assignment_Bound(self, var)
3496
3497    def SetMin(self, var, m):
3498        return _pywrapcp.Assignment_SetMin(self, var, m)
3499
3500    def SetMax(self, var, m):
3501        return _pywrapcp.Assignment_SetMax(self, var, m)
3502
3503    def SetRange(self, var, l, u):
3504        return _pywrapcp.Assignment_SetRange(self, var, l, u)
3505
3506    def SetValue(self, var, value):
3507        return _pywrapcp.Assignment_SetValue(self, var, value)
3508
3509    def StartMin(self, var):
3510        return _pywrapcp.Assignment_StartMin(self, var)
3511
3512    def StartMax(self, var):
3513        return _pywrapcp.Assignment_StartMax(self, var)
3514
3515    def StartValue(self, var):
3516        return _pywrapcp.Assignment_StartValue(self, var)
3517
3518    def DurationMin(self, var):
3519        return _pywrapcp.Assignment_DurationMin(self, var)
3520
3521    def DurationMax(self, var):
3522        return _pywrapcp.Assignment_DurationMax(self, var)
3523
3524    def DurationValue(self, var):
3525        return _pywrapcp.Assignment_DurationValue(self, var)
3526
3527    def EndMin(self, var):
3528        return _pywrapcp.Assignment_EndMin(self, var)
3529
3530    def EndMax(self, var):
3531        return _pywrapcp.Assignment_EndMax(self, var)
3532
3533    def EndValue(self, var):
3534        return _pywrapcp.Assignment_EndValue(self, var)
3535
3536    def PerformedMin(self, var):
3537        return _pywrapcp.Assignment_PerformedMin(self, var)
3538
3539    def PerformedMax(self, var):
3540        return _pywrapcp.Assignment_PerformedMax(self, var)
3541
3542    def PerformedValue(self, var):
3543        return _pywrapcp.Assignment_PerformedValue(self, var)
3544
3545    def SetStartMin(self, var, m):
3546        return _pywrapcp.Assignment_SetStartMin(self, var, m)
3547
3548    def SetStartMax(self, var, m):
3549        return _pywrapcp.Assignment_SetStartMax(self, var, m)
3550
3551    def SetStartRange(self, var, mi, ma):
3552        return _pywrapcp.Assignment_SetStartRange(self, var, mi, ma)
3553
3554    def SetStartValue(self, var, value):
3555        return _pywrapcp.Assignment_SetStartValue(self, var, value)
3556
3557    def SetDurationMin(self, var, m):
3558        return _pywrapcp.Assignment_SetDurationMin(self, var, m)
3559
3560    def SetDurationMax(self, var, m):
3561        return _pywrapcp.Assignment_SetDurationMax(self, var, m)
3562
3563    def SetDurationRange(self, var, mi, ma):
3564        return _pywrapcp.Assignment_SetDurationRange(self, var, mi, ma)
3565
3566    def SetDurationValue(self, var, value):
3567        return _pywrapcp.Assignment_SetDurationValue(self, var, value)
3568
3569    def SetEndMin(self, var, m):
3570        return _pywrapcp.Assignment_SetEndMin(self, var, m)
3571
3572    def SetEndMax(self, var, m):
3573        return _pywrapcp.Assignment_SetEndMax(self, var, m)
3574
3575    def SetEndRange(self, var, mi, ma):
3576        return _pywrapcp.Assignment_SetEndRange(self, var, mi, ma)
3577
3578    def SetEndValue(self, var, value):
3579        return _pywrapcp.Assignment_SetEndValue(self, var, value)
3580
3581    def SetPerformedMin(self, var, m):
3582        return _pywrapcp.Assignment_SetPerformedMin(self, var, m)
3583
3584    def SetPerformedMax(self, var, m):
3585        return _pywrapcp.Assignment_SetPerformedMax(self, var, m)
3586
3587    def SetPerformedRange(self, var, mi, ma):
3588        return _pywrapcp.Assignment_SetPerformedRange(self, var, mi, ma)
3589
3590    def SetPerformedValue(self, var, value):
3591        return _pywrapcp.Assignment_SetPerformedValue(self, var, value)
3592
3593    def Add(self, *args):
3594        return _pywrapcp.Assignment_Add(self, *args)
3595
3596    def ForwardSequence(self, var):
3597        return _pywrapcp.Assignment_ForwardSequence(self, var)
3598
3599    def BackwardSequence(self, var):
3600        return _pywrapcp.Assignment_BackwardSequence(self, var)
3601
3602    def Unperformed(self, var):
3603        return _pywrapcp.Assignment_Unperformed(self, var)
3604
3605    def SetSequence(self, var, forward_sequence, backward_sequence, unperformed):
3606        return _pywrapcp.Assignment_SetSequence(self, var, forward_sequence, backward_sequence, unperformed)
3607
3608    def SetForwardSequence(self, var, forward_sequence):
3609        return _pywrapcp.Assignment_SetForwardSequence(self, var, forward_sequence)
3610
3611    def SetBackwardSequence(self, var, backward_sequence):
3612        return _pywrapcp.Assignment_SetBackwardSequence(self, var, backward_sequence)
3613
3614    def SetUnperformed(self, var, unperformed):
3615        return _pywrapcp.Assignment_SetUnperformed(self, var, unperformed)
3616
3617    def Activate(self, *args):
3618        return _pywrapcp.Assignment_Activate(self, *args)
3619
3620    def Deactivate(self, *args):
3621        return _pywrapcp.Assignment_Deactivate(self, *args)
3622
3623    def Activated(self, *args):
3624        return _pywrapcp.Assignment_Activated(self, *args)
3625
3626    def DebugString(self):
3627        return _pywrapcp.Assignment_DebugString(self)
3628
3629    def IntVarContainer(self):
3630        return _pywrapcp.Assignment_IntVarContainer(self)
3631
3632    def MutableIntVarContainer(self):
3633        return _pywrapcp.Assignment_MutableIntVarContainer(self)
3634
3635    def IntervalVarContainer(self):
3636        return _pywrapcp.Assignment_IntervalVarContainer(self)
3637
3638    def MutableIntervalVarContainer(self):
3639        return _pywrapcp.Assignment_MutableIntervalVarContainer(self)
3640
3641    def SequenceVarContainer(self):
3642        return _pywrapcp.Assignment_SequenceVarContainer(self)
3643
3644    def MutableSequenceVarContainer(self):
3645        return _pywrapcp.Assignment_MutableSequenceVarContainer(self)
3646
3647    def __eq__(self, assignment):
3648        return _pywrapcp.Assignment___eq__(self, assignment)
3649
3650    def __ne__(self, assignment):
3651        return _pywrapcp.Assignment___ne__(self, assignment)

An Assignment is a variable -> domains mapping, used to report solutions to the user.

Assignment(*args, **kwargs)
3418    def __init__(self, *args, **kwargs):
3419        raise AttributeError("No constructor defined")
thisown

The membership flag

def Clear(self):
3422    def Clear(self):
3423        return _pywrapcp.Assignment_Clear(self)
def Empty(self):
3425    def Empty(self):
3426        return _pywrapcp.Assignment_Empty(self)
def Size(self):
3428    def Size(self):
3429        return _pywrapcp.Assignment_Size(self)
def NumIntVars(self):
3431    def NumIntVars(self):
3432        return _pywrapcp.Assignment_NumIntVars(self)
def NumIntervalVars(self):
3434    def NumIntervalVars(self):
3435        return _pywrapcp.Assignment_NumIntervalVars(self)
def NumSequenceVars(self):
3437    def NumSequenceVars(self):
3438        return _pywrapcp.Assignment_NumSequenceVars(self)
def Store(self):
3440    def Store(self):
3441        return _pywrapcp.Assignment_Store(self)
def Restore(self):
3443    def Restore(self):
3444        return _pywrapcp.Assignment_Restore(self)
def Load(self, *args):
3446    def Load(self, *args):
3447        return _pywrapcp.Assignment_Load(self, *args)
def Save(self, *args):
3449    def Save(self, *args):
3450        return _pywrapcp.Assignment_Save(self, *args)
def AddObjective(self, v):
3452    def AddObjective(self, v):
3453        return _pywrapcp.Assignment_AddObjective(self, v)
def Objective(self):
3455    def Objective(self):
3456        return _pywrapcp.Assignment_Objective(self)
def HasObjective(self):
3458    def HasObjective(self):
3459        return _pywrapcp.Assignment_HasObjective(self)
def ObjectiveMin(self):
3461    def ObjectiveMin(self):
3462        return _pywrapcp.Assignment_ObjectiveMin(self)
def ObjectiveMax(self):
3464    def ObjectiveMax(self):
3465        return _pywrapcp.Assignment_ObjectiveMax(self)
def ObjectiveValue(self):
3467    def ObjectiveValue(self):
3468        return _pywrapcp.Assignment_ObjectiveValue(self)
def ObjectiveBound(self):
3470    def ObjectiveBound(self):
3471        return _pywrapcp.Assignment_ObjectiveBound(self)
def SetObjectiveMin(self, m):
3473    def SetObjectiveMin(self, m):
3474        return _pywrapcp.Assignment_SetObjectiveMin(self, m)
def SetObjectiveMax(self, m):
3476    def SetObjectiveMax(self, m):
3477        return _pywrapcp.Assignment_SetObjectiveMax(self, m)
def SetObjectiveValue(self, value):
3479    def SetObjectiveValue(self, value):
3480        return _pywrapcp.Assignment_SetObjectiveValue(self, value)
def SetObjectiveRange(self, l, u):
3482    def SetObjectiveRange(self, l, u):
3483        return _pywrapcp.Assignment_SetObjectiveRange(self, l, u)
def Min(self, var):
3485    def Min(self, var):
3486        return _pywrapcp.Assignment_Min(self, var)
def Max(self, var):
3488    def Max(self, var):
3489        return _pywrapcp.Assignment_Max(self, var)
def Value(self, var):
3491    def Value(self, var):
3492        return _pywrapcp.Assignment_Value(self, var)
def Bound(self, var):
3494    def Bound(self, var):
3495        return _pywrapcp.Assignment_Bound(self, var)
def SetMin(self, var, m):
3497    def SetMin(self, var, m):
3498        return _pywrapcp.Assignment_SetMin(self, var, m)
def SetMax(self, var, m):
3500    def SetMax(self, var, m):
3501        return _pywrapcp.Assignment_SetMax(self, var, m)
def SetRange(self, var, l, u):
3503    def SetRange(self, var, l, u):
3504        return _pywrapcp.Assignment_SetRange(self, var, l, u)
def SetValue(self, var, value):
3506    def SetValue(self, var, value):
3507        return _pywrapcp.Assignment_SetValue(self, var, value)
def StartMin(self, var):
3509    def StartMin(self, var):
3510        return _pywrapcp.Assignment_StartMin(self, var)
def StartMax(self, var):
3512    def StartMax(self, var):
3513        return _pywrapcp.Assignment_StartMax(self, var)
def StartValue(self, var):
3515    def StartValue(self, var):
3516        return _pywrapcp.Assignment_StartValue(self, var)
def DurationMin(self, var):
3518    def DurationMin(self, var):
3519        return _pywrapcp.Assignment_DurationMin(self, var)
def DurationMax(self, var):
3521    def DurationMax(self, var):
3522        return _pywrapcp.Assignment_DurationMax(self, var)
def DurationValue(self, var):
3524    def DurationValue(self, var):
3525        return _pywrapcp.Assignment_DurationValue(self, var)
def EndMin(self, var):
3527    def EndMin(self, var):
3528        return _pywrapcp.Assignment_EndMin(self, var)
def EndMax(self, var):
3530    def EndMax(self, var):
3531        return _pywrapcp.Assignment_EndMax(self, var)
def EndValue(self, var):
3533    def EndValue(self, var):
3534        return _pywrapcp.Assignment_EndValue(self, var)
def PerformedMin(self, var):
3536    def PerformedMin(self, var):
3537        return _pywrapcp.Assignment_PerformedMin(self, var)
def PerformedMax(self, var):
3539    def PerformedMax(self, var):
3540        return _pywrapcp.Assignment_PerformedMax(self, var)
def PerformedValue(self, var):
3542    def PerformedValue(self, var):
3543        return _pywrapcp.Assignment_PerformedValue(self, var)
def SetStartMin(self, var, m):
3545    def SetStartMin(self, var, m):
3546        return _pywrapcp.Assignment_SetStartMin(self, var, m)
def SetStartMax(self, var, m):
3548    def SetStartMax(self, var, m):
3549        return _pywrapcp.Assignment_SetStartMax(self, var, m)
def SetStartRange(self, var, mi, ma):
3551    def SetStartRange(self, var, mi, ma):
3552        return _pywrapcp.Assignment_SetStartRange(self, var, mi, ma)
def SetStartValue(self, var, value):
3554    def SetStartValue(self, var, value):
3555        return _pywrapcp.Assignment_SetStartValue(self, var, value)
def SetDurationMin(self, var, m):
3557    def SetDurationMin(self, var, m):
3558        return _pywrapcp.Assignment_SetDurationMin(self, var, m)
def SetDurationMax(self, var, m):
3560    def SetDurationMax(self, var, m):
3561        return _pywrapcp.Assignment_SetDurationMax(self, var, m)
def SetDurationRange(self, var, mi, ma):
3563    def SetDurationRange(self, var, mi, ma):
3564        return _pywrapcp.Assignment_SetDurationRange(self, var, mi, ma)
def SetDurationValue(self, var, value):
3566    def SetDurationValue(self, var, value):
3567        return _pywrapcp.Assignment_SetDurationValue(self, var, value)
def SetEndMin(self, var, m):
3569    def SetEndMin(self, var, m):
3570        return _pywrapcp.Assignment_SetEndMin(self, var, m)
def SetEndMax(self, var, m):
3572    def SetEndMax(self, var, m):
3573        return _pywrapcp.Assignment_SetEndMax(self, var, m)
def SetEndRange(self, var, mi, ma):
3575    def SetEndRange(self, var, mi, ma):
3576        return _pywrapcp.Assignment_SetEndRange(self, var, mi, ma)
def SetEndValue(self, var, value):
3578    def SetEndValue(self, var, value):
3579        return _pywrapcp.Assignment_SetEndValue(self, var, value)
def SetPerformedMin(self, var, m):
3581    def SetPerformedMin(self, var, m):
3582        return _pywrapcp.Assignment_SetPerformedMin(self, var, m)
def SetPerformedMax(self, var, m):
3584    def SetPerformedMax(self, var, m):
3585        return _pywrapcp.Assignment_SetPerformedMax(self, var, m)
def SetPerformedRange(self, var, mi, ma):
3587    def SetPerformedRange(self, var, mi, ma):
3588        return _pywrapcp.Assignment_SetPerformedRange(self, var, mi, ma)
def SetPerformedValue(self, var, value):
3590    def SetPerformedValue(self, var, value):
3591        return _pywrapcp.Assignment_SetPerformedValue(self, var, value)
def Add(self, *args):
3593    def Add(self, *args):
3594        return _pywrapcp.Assignment_Add(self, *args)
def ForwardSequence(self, var):
3596    def ForwardSequence(self, var):
3597        return _pywrapcp.Assignment_ForwardSequence(self, var)
def BackwardSequence(self, var):
3599    def BackwardSequence(self, var):
3600        return _pywrapcp.Assignment_BackwardSequence(self, var)
def Unperformed(self, var):
3602    def Unperformed(self, var):
3603        return _pywrapcp.Assignment_Unperformed(self, var)
def SetSequence(self, var, forward_sequence, backward_sequence, unperformed):
3605    def SetSequence(self, var, forward_sequence, backward_sequence, unperformed):
3606        return _pywrapcp.Assignment_SetSequence(self, var, forward_sequence, backward_sequence, unperformed)
def SetForwardSequence(self, var, forward_sequence):
3608    def SetForwardSequence(self, var, forward_sequence):
3609        return _pywrapcp.Assignment_SetForwardSequence(self, var, forward_sequence)
def SetBackwardSequence(self, var, backward_sequence):
3611    def SetBackwardSequence(self, var, backward_sequence):
3612        return _pywrapcp.Assignment_SetBackwardSequence(self, var, backward_sequence)
def SetUnperformed(self, var, unperformed):
3614    def SetUnperformed(self, var, unperformed):
3615        return _pywrapcp.Assignment_SetUnperformed(self, var, unperformed)
def Activate(self, *args):
3617    def Activate(self, *args):
3618        return _pywrapcp.Assignment_Activate(self, *args)
def Deactivate(self, *args):
3620    def Deactivate(self, *args):
3621        return _pywrapcp.Assignment_Deactivate(self, *args)
def Activated(self, *args):
3623    def Activated(self, *args):
3624        return _pywrapcp.Assignment_Activated(self, *args)
def DebugString(self):
3626    def DebugString(self):
3627        return _pywrapcp.Assignment_DebugString(self)
def IntVarContainer(self):
3629    def IntVarContainer(self):
3630        return _pywrapcp.Assignment_IntVarContainer(self)
def MutableIntVarContainer(self):
3632    def MutableIntVarContainer(self):
3633        return _pywrapcp.Assignment_MutableIntVarContainer(self)
def IntervalVarContainer(self):
3635    def IntervalVarContainer(self):
3636        return _pywrapcp.Assignment_IntervalVarContainer(self)
def MutableIntervalVarContainer(self):
3638    def MutableIntervalVarContainer(self):
3639        return _pywrapcp.Assignment_MutableIntervalVarContainer(self)
def SequenceVarContainer(self):
3641    def SequenceVarContainer(self):
3642        return _pywrapcp.Assignment_SequenceVarContainer(self)
def MutableSequenceVarContainer(self):
3644    def MutableSequenceVarContainer(self):
3645        return _pywrapcp.Assignment_MutableSequenceVarContainer(self)
Inherited Members
PropagationBaseObject
solver
Name
class Pack(Constraint):
3658class Pack(Constraint):
3659    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3660
3661    def __init__(self, *args, **kwargs):
3662        raise AttributeError("No constructor defined")
3663    __repr__ = _swig_repr
3664
3665    def AddWeightedSumLessOrEqualConstantDimension(self, *args):
3666        r"""
3667        *Overload 1:*
3668        Dimensions are additional constraints than can restrict what is
3669        possible with the pack constraint. It can be used to set capacity
3670        limits, to count objects per bin, to compute unassigned
3671        penalties...
3672        This dimension imposes that for all bins b, the weighted sum
3673        (weights[i]) of all objects i assigned to 'b' is less or equal
3674        'bounds[b]'.
3675
3676        |
3677
3678        *Overload 2:*
3679        This dimension imposes that for all bins b, the weighted sum
3680        (weights->Run(i)) of all objects i assigned to 'b' is less or
3681        equal to 'bounds[b]'. Ownership of the callback is transferred to
3682        the pack constraint.
3683
3684        |
3685
3686        *Overload 3:*
3687        This dimension imposes that for all bins b, the weighted sum
3688        (weights->Run(i, b) of all objects i assigned to 'b' is less or
3689        equal to 'bounds[b]'. Ownership of the callback is transferred to
3690        the pack constraint.
3691        """
3692        return _pywrapcp.Pack_AddWeightedSumLessOrEqualConstantDimension(self, *args)
3693
3694    def AddWeightedSumEqualVarDimension(self, *args):
3695        r"""
3696        *Overload 1:*
3697        This dimension imposes that for all bins b, the weighted sum
3698        (weights[i]) of all objects i assigned to 'b' is equal to loads[b].
3699
3700        |
3701
3702        *Overload 2:*
3703        This dimension imposes that for all bins b, the weighted sum
3704        (weights->Run(i, b)) of all objects i assigned to 'b' is equal to
3705        loads[b].
3706        """
3707        return _pywrapcp.Pack_AddWeightedSumEqualVarDimension(self, *args)
3708
3709    def AddSumVariableWeightsLessOrEqualConstantDimension(self, usage, capacity):
3710        r"""
3711        This dimension imposes:
3712        forall b in bins,
3713           sum (i in items: usage[i] * is_assigned(i, b)) <= capacity[b]
3714        where is_assigned(i, b) is true if and only if item i is assigned
3715        to the bin b.
3716
3717        This can be used to model shapes of items by linking variables of
3718        the same item on parallel dimensions with an allowed assignment
3719        constraint.
3720        """
3721        return _pywrapcp.Pack_AddSumVariableWeightsLessOrEqualConstantDimension(self, usage, capacity)
3722
3723    def AddWeightedSumOfAssignedDimension(self, weights, cost_var):
3724        r"""
3725        This dimension enforces that cost_var == sum of weights[i] for
3726        all objects 'i' assigned to a bin.
3727        """
3728        return _pywrapcp.Pack_AddWeightedSumOfAssignedDimension(self, weights, cost_var)
3729
3730    def AddCountUsedBinDimension(self, count_var):
3731        r"""
3732        This dimension links 'count_var' to the actual number of bins used in the
3733        pack.
3734        """
3735        return _pywrapcp.Pack_AddCountUsedBinDimension(self, count_var)
3736
3737    def AddCountAssignedItemsDimension(self, count_var):
3738        r"""
3739        This dimension links 'count_var' to the actual number of items
3740        assigned to a bin in the pack.
3741        """
3742        return _pywrapcp.Pack_AddCountAssignedItemsDimension(self, count_var)
3743
3744    def Post(self):
3745        return _pywrapcp.Pack_Post(self)
3746
3747    def InitialPropagateWrapper(self):
3748        return _pywrapcp.Pack_InitialPropagateWrapper(self)
3749
3750    def DebugString(self):
3751        return _pywrapcp.Pack_DebugString(self)

A constraint is the main modeling object. It provides two methods:

  • Post() is responsible for creating the demons and attaching them to immediate demons().
  • InitialPropagate() is called once just after Post and performs the initial propagation. The subsequent propagations will be performed by the demons Posted during the post() method.
Pack(*args, **kwargs)
3661    def __init__(self, *args, **kwargs):
3662        raise AttributeError("No constructor defined")
thisown

The membership flag

def AddWeightedSumLessOrEqualConstantDimension(self, *args):
3665    def AddWeightedSumLessOrEqualConstantDimension(self, *args):
3666        r"""
3667        *Overload 1:*
3668        Dimensions are additional constraints than can restrict what is
3669        possible with the pack constraint. It can be used to set capacity
3670        limits, to count objects per bin, to compute unassigned
3671        penalties...
3672        This dimension imposes that for all bins b, the weighted sum
3673        (weights[i]) of all objects i assigned to 'b' is less or equal
3674        'bounds[b]'.
3675
3676        |
3677
3678        *Overload 2:*
3679        This dimension imposes that for all bins b, the weighted sum
3680        (weights->Run(i)) of all objects i assigned to 'b' is less or
3681        equal to 'bounds[b]'. Ownership of the callback is transferred to
3682        the pack constraint.
3683
3684        |
3685
3686        *Overload 3:*
3687        This dimension imposes that for all bins b, the weighted sum
3688        (weights->Run(i, b) of all objects i assigned to 'b' is less or
3689        equal to 'bounds[b]'. Ownership of the callback is transferred to
3690        the pack constraint.
3691        """
3692        return _pywrapcp.Pack_AddWeightedSumLessOrEqualConstantDimension(self, *args)

Overload 1: Dimensions are additional constraints than can restrict what is possible with the pack constraint. It can be used to set capacity limits, to count objects per bin, to compute unassigned penalties... This dimension imposes that for all bins b, the weighted sum (weights[i]) of all objects i assigned to 'b' is less or equal 'bounds[b]'.

|

Overload 2: This dimension imposes that for all bins b, the weighted sum (weights->Run(i)) of all objects i assigned to 'b' is less or equal to 'bounds[b]'. Ownership of the callback is transferred to the pack constraint.

|

Overload 3: This dimension imposes that for all bins b, the weighted sum (weights->Run(i, b) of all objects i assigned to 'b' is less or equal to 'bounds[b]'. Ownership of the callback is transferred to the pack constraint.

def AddWeightedSumEqualVarDimension(self, *args):
3694    def AddWeightedSumEqualVarDimension(self, *args):
3695        r"""
3696        *Overload 1:*
3697        This dimension imposes that for all bins b, the weighted sum
3698        (weights[i]) of all objects i assigned to 'b' is equal to loads[b].
3699
3700        |
3701
3702        *Overload 2:*
3703        This dimension imposes that for all bins b, the weighted sum
3704        (weights->Run(i, b)) of all objects i assigned to 'b' is equal to
3705        loads[b].
3706        """
3707        return _pywrapcp.Pack_AddWeightedSumEqualVarDimension(self, *args)

Overload 1: This dimension imposes that for all bins b, the weighted sum (weights[i]) of all objects i assigned to 'b' is equal to loads[b].

|

Overload 2: This dimension imposes that for all bins b, the weighted sum (weights->Run(i, b)) of all objects i assigned to 'b' is equal to loads[b].

def AddSumVariableWeightsLessOrEqualConstantDimension(self, usage, capacity):
3709    def AddSumVariableWeightsLessOrEqualConstantDimension(self, usage, capacity):
3710        r"""
3711        This dimension imposes:
3712        forall b in bins,
3713           sum (i in items: usage[i] * is_assigned(i, b)) <= capacity[b]
3714        where is_assigned(i, b) is true if and only if item i is assigned
3715        to the bin b.
3716
3717        This can be used to model shapes of items by linking variables of
3718        the same item on parallel dimensions with an allowed assignment
3719        constraint.
3720        """
3721        return _pywrapcp.Pack_AddSumVariableWeightsLessOrEqualConstantDimension(self, usage, capacity)

This dimension imposes: forall b in bins, sum (i in items: usage[i] * is_assigned(i, b)) <= capacity[b] where is_assigned(i, b) is true if and only if item i is assigned to the bin b.

This can be used to model shapes of items by linking variables of the same item on parallel dimensions with an allowed assignment constraint.

def AddWeightedSumOfAssignedDimension(self, weights, cost_var):
3723    def AddWeightedSumOfAssignedDimension(self, weights, cost_var):
3724        r"""
3725        This dimension enforces that cost_var == sum of weights[i] for
3726        all objects 'i' assigned to a bin.
3727        """
3728        return _pywrapcp.Pack_AddWeightedSumOfAssignedDimension(self, weights, cost_var)

This dimension enforces that cost_var == sum of weights[i] for all objects 'i' assigned to a bin.

def AddCountUsedBinDimension(self, count_var):
3730    def AddCountUsedBinDimension(self, count_var):
3731        r"""
3732        This dimension links 'count_var' to the actual number of bins used in the
3733        pack.
3734        """
3735        return _pywrapcp.Pack_AddCountUsedBinDimension(self, count_var)

This dimension links 'count_var' to the actual number of bins used in the pack.

def AddCountAssignedItemsDimension(self, count_var):
3737    def AddCountAssignedItemsDimension(self, count_var):
3738        r"""
3739        This dimension links 'count_var' to the actual number of items
3740        assigned to a bin in the pack.
3741        """
3742        return _pywrapcp.Pack_AddCountAssignedItemsDimension(self, count_var)

This dimension links 'count_var' to the actual number of items assigned to a bin in the pack.

def Post(self):
3744    def Post(self):
3745        return _pywrapcp.Pack_Post(self)

This method is called when the constraint is processed by the solver. Its main usage is to attach demons to variables.

def InitialPropagateWrapper(self):
3747    def InitialPropagateWrapper(self):
3748        return _pywrapcp.Pack_InitialPropagateWrapper(self)

This method performs the initial propagation of the constraint. It is called just after the post.

def DebugString(self):
3750    def DebugString(self):
3751        return _pywrapcp.Pack_DebugString(self)
class DisjunctiveConstraint(Constraint):
3755class DisjunctiveConstraint(Constraint):
3756    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3757
3758    def __init__(self, *args, **kwargs):
3759        raise AttributeError("No constructor defined - class is abstract")
3760    __repr__ = _swig_repr
3761
3762    def SequenceVar(self):
3763        r""" Creates a sequence variable from the constraint."""
3764        return _pywrapcp.DisjunctiveConstraint_SequenceVar(self)
3765
3766    def SetTransitionTime(self, transition_time):
3767        r"""
3768        Add a transition time between intervals.  It forces the distance between
3769        the end of interval a and start of interval b that follows it to be at
3770        least transition_time(a, b). This function must always return
3771        a positive or null value.
3772        """
3773        return _pywrapcp.DisjunctiveConstraint_SetTransitionTime(self, transition_time)
3774
3775    def TransitionTime(self, before_index, after_index):
3776        return _pywrapcp.DisjunctiveConstraint_TransitionTime(self, before_index, after_index)

A constraint is the main modeling object. It provides two methods:

  • Post() is responsible for creating the demons and attaching them to immediate demons().
  • InitialPropagate() is called once just after Post and performs the initial propagation. The subsequent propagations will be performed by the demons Posted during the post() method.
DisjunctiveConstraint(*args, **kwargs)
3758    def __init__(self, *args, **kwargs):
3759        raise AttributeError("No constructor defined - class is abstract")
thisown

The membership flag

def SequenceVar(self):
3762    def SequenceVar(self):
3763        r""" Creates a sequence variable from the constraint."""
3764        return _pywrapcp.DisjunctiveConstraint_SequenceVar(self)

Creates a sequence variable from the constraint.

def SetTransitionTime(self, transition_time):
3766    def SetTransitionTime(self, transition_time):
3767        r"""
3768        Add a transition time between intervals.  It forces the distance between
3769        the end of interval a and start of interval b that follows it to be at
3770        least transition_time(a, b). This function must always return
3771        a positive or null value.
3772        """
3773        return _pywrapcp.DisjunctiveConstraint_SetTransitionTime(self, transition_time)

Add a transition time between intervals. It forces the distance between the end of interval a and start of interval b that follows it to be at least transition_time(a, b). This function must always return a positive or null value.

def TransitionTime(self, before_index, after_index):
3775    def TransitionTime(self, before_index, after_index):
3776        return _pywrapcp.DisjunctiveConstraint_TransitionTime(self, before_index, after_index)
class RevInteger:
3780class RevInteger(object):
3781    r"""
3782    This class adds reversibility to a POD type.
3783    It contains the stamp optimization. i.e. the SaveValue call is done
3784    only once per node of the search tree.  Please note that actual
3785    stamps always starts at 1, thus an initial value of 0 will always
3786    trigger the first SaveValue.
3787    """
3788
3789    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3790    __repr__ = _swig_repr
3791
3792    def __init__(self, val):
3793        _pywrapcp.RevInteger_swiginit(self, _pywrapcp.new_RevInteger(val))
3794
3795    def Value(self):
3796        return _pywrapcp.RevInteger_Value(self)
3797
3798    def SetValue(self, s, val):
3799        return _pywrapcp.RevInteger_SetValue(self, s, val)
3800    __swig_destroy__ = _pywrapcp.delete_RevInteger

This class adds reversibility to a POD type. It contains the stamp optimization. i.e. the SaveValue call is done only once per node of the search tree. Please note that actual stamps always starts at 1, thus an initial value of 0 will always trigger the first SaveValue.

RevInteger(val)
3792    def __init__(self, val):
3793        _pywrapcp.RevInteger_swiginit(self, _pywrapcp.new_RevInteger(val))
thisown

The membership flag

def Value(self):
3795    def Value(self):
3796        return _pywrapcp.RevInteger_Value(self)
def SetValue(self, s, val):
3798    def SetValue(self, s, val):
3799        return _pywrapcp.RevInteger_SetValue(self, s, val)
class NumericalRevInteger(RevInteger):
3804class NumericalRevInteger(RevInteger):
3805    r""" Subclass of Rev<T> which adds numerical operations."""
3806
3807    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3808    __repr__ = _swig_repr
3809
3810    def __init__(self, val):
3811        _pywrapcp.NumericalRevInteger_swiginit(self, _pywrapcp.new_NumericalRevInteger(val))
3812
3813    def Add(self, s, to_add):
3814        return _pywrapcp.NumericalRevInteger_Add(self, s, to_add)
3815
3816    def Incr(self, s):
3817        return _pywrapcp.NumericalRevInteger_Incr(self, s)
3818
3819    def Decr(self, s):
3820        return _pywrapcp.NumericalRevInteger_Decr(self, s)
3821    __swig_destroy__ = _pywrapcp.delete_NumericalRevInteger

Subclass of Rev which adds numerical operations.

NumericalRevInteger(val)
3810    def __init__(self, val):
3811        _pywrapcp.NumericalRevInteger_swiginit(self, _pywrapcp.new_NumericalRevInteger(val))
thisown

The membership flag

def Add(self, s, to_add):
3813    def Add(self, s, to_add):
3814        return _pywrapcp.NumericalRevInteger_Add(self, s, to_add)
def Incr(self, s):
3816    def Incr(self, s):
3817        return _pywrapcp.NumericalRevInteger_Incr(self, s)
def Decr(self, s):
3819    def Decr(self, s):
3820        return _pywrapcp.NumericalRevInteger_Decr(self, s)
Inherited Members
RevInteger
Value
SetValue
class RevBool:
3825class RevBool(object):
3826    r"""
3827    This class adds reversibility to a POD type.
3828    It contains the stamp optimization. i.e. the SaveValue call is done
3829    only once per node of the search tree.  Please note that actual
3830    stamps always starts at 1, thus an initial value of 0 will always
3831    trigger the first SaveValue.
3832    """
3833
3834    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3835    __repr__ = _swig_repr
3836
3837    def __init__(self, val):
3838        _pywrapcp.RevBool_swiginit(self, _pywrapcp.new_RevBool(val))
3839
3840    def Value(self):
3841        return _pywrapcp.RevBool_Value(self)
3842
3843    def SetValue(self, s, val):
3844        return _pywrapcp.RevBool_SetValue(self, s, val)
3845    __swig_destroy__ = _pywrapcp.delete_RevBool

This class adds reversibility to a POD type. It contains the stamp optimization. i.e. the SaveValue call is done only once per node of the search tree. Please note that actual stamps always starts at 1, thus an initial value of 0 will always trigger the first SaveValue.

RevBool(val)
3837    def __init__(self, val):
3838        _pywrapcp.RevBool_swiginit(self, _pywrapcp.new_RevBool(val))
thisown

The membership flag

def Value(self):
3840    def Value(self):
3841        return _pywrapcp.RevBool_Value(self)
def SetValue(self, s, val):
3843    def SetValue(self, s, val):
3844        return _pywrapcp.RevBool_SetValue(self, s, val)
class IntVarContainer:
3849class IntVarContainer(object):
3850    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3851
3852    def __init__(self, *args, **kwargs):
3853        raise AttributeError("No constructor defined")
3854    __repr__ = _swig_repr
3855
3856    def Contains(self, var):
3857        return _pywrapcp.IntVarContainer_Contains(self, var)
3858
3859    def Element(self, index):
3860        return _pywrapcp.IntVarContainer_Element(self, index)
3861
3862    def Size(self):
3863        return _pywrapcp.IntVarContainer_Size(self)
3864
3865    def Store(self):
3866        return _pywrapcp.IntVarContainer_Store(self)
3867
3868    def Restore(self):
3869        return _pywrapcp.IntVarContainer_Restore(self)
3870
3871    def __eq__(self, container):
3872        r"""
3873        Returns true if this and 'container' both represent the same V* -> E map.
3874        Runs in linear time; requires that the == operator on the type E is well
3875        defined.
3876        """
3877        return _pywrapcp.IntVarContainer___eq__(self, container)
3878
3879    def __ne__(self, container):
3880        return _pywrapcp.IntVarContainer___ne__(self, container)
3881    __swig_destroy__ = _pywrapcp.delete_IntVarContainer
IntVarContainer(*args, **kwargs)
3852    def __init__(self, *args, **kwargs):
3853        raise AttributeError("No constructor defined")
thisown

The membership flag

def Contains(self, var):
3856    def Contains(self, var):
3857        return _pywrapcp.IntVarContainer_Contains(self, var)
def Element(self, index):
3859    def Element(self, index):
3860        return _pywrapcp.IntVarContainer_Element(self, index)
def Size(self):
3862    def Size(self):
3863        return _pywrapcp.IntVarContainer_Size(self)
def Store(self):
3865    def Store(self):
3866        return _pywrapcp.IntVarContainer_Store(self)
def Restore(self):
3868    def Restore(self):
3869        return _pywrapcp.IntVarContainer_Restore(self)
class IntervalVarContainer:
3885class IntervalVarContainer(object):
3886    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3887
3888    def __init__(self, *args, **kwargs):
3889        raise AttributeError("No constructor defined")
3890    __repr__ = _swig_repr
3891
3892    def Contains(self, var):
3893        return _pywrapcp.IntervalVarContainer_Contains(self, var)
3894
3895    def Element(self, index):
3896        return _pywrapcp.IntervalVarContainer_Element(self, index)
3897
3898    def Size(self):
3899        return _pywrapcp.IntervalVarContainer_Size(self)
3900
3901    def Store(self):
3902        return _pywrapcp.IntervalVarContainer_Store(self)
3903
3904    def Restore(self):
3905        return _pywrapcp.IntervalVarContainer_Restore(self)
3906
3907    def __eq__(self, container):
3908        r"""
3909        Returns true if this and 'container' both represent the same V* -> E map.
3910        Runs in linear time; requires that the == operator on the type E is well
3911        defined.
3912        """
3913        return _pywrapcp.IntervalVarContainer___eq__(self, container)
3914
3915    def __ne__(self, container):
3916        return _pywrapcp.IntervalVarContainer___ne__(self, container)
3917    __swig_destroy__ = _pywrapcp.delete_IntervalVarContainer
IntervalVarContainer(*args, **kwargs)
3888    def __init__(self, *args, **kwargs):
3889        raise AttributeError("No constructor defined")
thisown

The membership flag

def Contains(self, var):
3892    def Contains(self, var):
3893        return _pywrapcp.IntervalVarContainer_Contains(self, var)
def Element(self, index):
3895    def Element(self, index):
3896        return _pywrapcp.IntervalVarContainer_Element(self, index)
def Size(self):
3898    def Size(self):
3899        return _pywrapcp.IntervalVarContainer_Size(self)
def Store(self):
3901    def Store(self):
3902        return _pywrapcp.IntervalVarContainer_Store(self)
def Restore(self):
3904    def Restore(self):
3905        return _pywrapcp.IntervalVarContainer_Restore(self)
class SequenceVarContainer:
3921class SequenceVarContainer(object):
3922    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3923
3924    def __init__(self, *args, **kwargs):
3925        raise AttributeError("No constructor defined")
3926    __repr__ = _swig_repr
3927
3928    def Contains(self, var):
3929        return _pywrapcp.SequenceVarContainer_Contains(self, var)
3930
3931    def Element(self, index):
3932        return _pywrapcp.SequenceVarContainer_Element(self, index)
3933
3934    def Size(self):
3935        return _pywrapcp.SequenceVarContainer_Size(self)
3936
3937    def Store(self):
3938        return _pywrapcp.SequenceVarContainer_Store(self)
3939
3940    def Restore(self):
3941        return _pywrapcp.SequenceVarContainer_Restore(self)
3942
3943    def __eq__(self, container):
3944        r"""
3945        Returns true if this and 'container' both represent the same V* -> E map.
3946        Runs in linear time; requires that the == operator on the type E is well
3947        defined.
3948        """
3949        return _pywrapcp.SequenceVarContainer___eq__(self, container)
3950
3951    def __ne__(self, container):
3952        return _pywrapcp.SequenceVarContainer___ne__(self, container)
3953    __swig_destroy__ = _pywrapcp.delete_SequenceVarContainer
SequenceVarContainer(*args, **kwargs)
3924    def __init__(self, *args, **kwargs):
3925        raise AttributeError("No constructor defined")
thisown

The membership flag

def Contains(self, var):
3928    def Contains(self, var):
3929        return _pywrapcp.SequenceVarContainer_Contains(self, var)
def Element(self, index):
3931    def Element(self, index):
3932        return _pywrapcp.SequenceVarContainer_Element(self, index)
def Size(self):
3934    def Size(self):
3935        return _pywrapcp.SequenceVarContainer_Size(self)
def Store(self):
3937    def Store(self):
3938        return _pywrapcp.SequenceVarContainer_Store(self)
def Restore(self):
3940    def Restore(self):
3941        return _pywrapcp.SequenceVarContainer_Restore(self)
class LocalSearchOperator(BaseObject):
3957class LocalSearchOperator(BaseObject):
3958    r"""
3959    The base class for all local search operators.
3960
3961    A local search operator is an object that defines the neighborhood of a
3962    solution. In other words, a neighborhood is the set of solutions which can
3963    be reached from a given solution using an operator.
3964
3965    The behavior of the LocalSearchOperator class is similar to iterators.
3966    The operator is synchronized with an assignment (gives the
3967    current values of the variables); this is done in the Start() method.
3968
3969    Then one can iterate over the neighbors using the MakeNextNeighbor method.
3970    This method returns an assignment which represents the incremental changes
3971    to the current solution. It also returns a second assignment representing
3972    the changes to the last solution defined by the neighborhood operator; this
3973    assignment is empty if the neighborhood operator cannot track this
3974    information.
3975    """
3976
3977    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
3978
3979    def __init__(self, *args, **kwargs):
3980        raise AttributeError("No constructor defined - class is abstract")
3981    __repr__ = _swig_repr
3982
3983    def NextNeighbor(self, delta, deltadelta):
3984        return _pywrapcp.LocalSearchOperator_NextNeighbor(self, delta, deltadelta)
3985
3986    def Start(self, assignment):
3987        return _pywrapcp.LocalSearchOperator_Start(self, assignment)
3988    def __disown__(self):
3989        self.this.disown()
3990        _pywrapcp.disown_LocalSearchOperator(self)
3991        return weakref.proxy(self)

The base class for all local search operators.

A local search operator is an object that defines the neighborhood of a solution. In other words, a neighborhood is the set of solutions which can be reached from a given solution using an operator.

The behavior of the LocalSearchOperator class is similar to iterators. The operator is synchronized with an assignment (gives the current values of the variables); this is done in the Start() method.

Then one can iterate over the neighbors using the MakeNextNeighbor method. This method returns an assignment which represents the incremental changes to the current solution. It also returns a second assignment representing the changes to the last solution defined by the neighborhood operator; this assignment is empty if the neighborhood operator cannot track this information.

LocalSearchOperator(*args, **kwargs)
3979    def __init__(self, *args, **kwargs):
3980        raise AttributeError("No constructor defined - class is abstract")
thisown

The membership flag

def NextNeighbor(self, delta, deltadelta):
3983    def NextNeighbor(self, delta, deltadelta):
3984        return _pywrapcp.LocalSearchOperator_NextNeighbor(self, delta, deltadelta)
def Start(self, assignment):
3986    def Start(self, assignment):
3987        return _pywrapcp.LocalSearchOperator_Start(self, assignment)
Inherited Members
BaseObject
DebugString
class IntVarLocalSearchOperator(LocalSearchOperator):
3995class IntVarLocalSearchOperator(LocalSearchOperator):
3996    r"""
3997    Specialization of LocalSearchOperator built from an array of IntVars
3998    which specifies the scope of the operator.
3999    This class also takes care of storing current variable values in Start(),
4000    keeps track of changes done by the operator and builds the delta.
4001    The Deactivate() method can be used to perform Large Neighborhood Search.
4002    """
4003
4004    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4005    __repr__ = _swig_repr
4006
4007    def __init__(self, vars, keep_inverse_values=False):
4008        if self.__class__ == IntVarLocalSearchOperator:
4009            _self = None
4010        else:
4011            _self = self
4012        _pywrapcp.IntVarLocalSearchOperator_swiginit(self, _pywrapcp.new_IntVarLocalSearchOperator(_self, vars, keep_inverse_values))
4013    __swig_destroy__ = _pywrapcp.delete_IntVarLocalSearchOperator
4014
4015    def Start(self, assignment):
4016        r"""
4017        This method should not be overridden. Override OnStart() instead which is
4018        called before exiting this method.
4019        """
4020        return _pywrapcp.IntVarLocalSearchOperator_Start(self, assignment)
4021
4022    def IsIncremental(self):
4023        return _pywrapcp.IntVarLocalSearchOperator_IsIncremental(self)
4024
4025    def Size(self):
4026        return _pywrapcp.IntVarLocalSearchOperator_Size(self)
4027
4028    def Value(self, index):
4029        r"""
4030        Returns the value in the current assignment of the variable of given
4031        index.
4032        """
4033        return _pywrapcp.IntVarLocalSearchOperator_Value(self, index)
4034
4035    def Var(self, index):
4036        r""" Returns the variable of given index."""
4037        return _pywrapcp.IntVarLocalSearchOperator_Var(self, index)
4038
4039    def OldValue(self, index):
4040        return _pywrapcp.IntVarLocalSearchOperator_OldValue(self, index)
4041
4042    def PrevValue(self, index):
4043        return _pywrapcp.IntVarLocalSearchOperator_PrevValue(self, index)
4044
4045    def SetValue(self, index, value):
4046        return _pywrapcp.IntVarLocalSearchOperator_SetValue(self, index, value)
4047
4048    def Activated(self, index):
4049        return _pywrapcp.IntVarLocalSearchOperator_Activated(self, index)
4050
4051    def Activate(self, index):
4052        return _pywrapcp.IntVarLocalSearchOperator_Activate(self, index)
4053
4054    def Deactivate(self, index):
4055        return _pywrapcp.IntVarLocalSearchOperator_Deactivate(self, index)
4056
4057    def AddVars(self, vars):
4058        return _pywrapcp.IntVarLocalSearchOperator_AddVars(self, vars)
4059
4060    def OnStart(self):
4061        r"""
4062        Called by Start() after synchronizing the operator with the current
4063        assignment. Should be overridden instead of Start() to avoid calling
4064        IntVarLocalSearchOperator::Start explicitly.
4065        """
4066        return _pywrapcp.IntVarLocalSearchOperator_OnStart(self)
4067
4068    def NextNeighbor(self, delta, deltadelta):
4069        r"""
4070        OnStart() should really be protected, but then SWIG doesn't see it. So we
4071        make it public, but only subclasses should access to it (to override it).
4072        Redefines MakeNextNeighbor to export a simpler interface. The calls to
4073        ApplyChanges() and RevertChanges() are factored in this method, hiding
4074        both delta and deltadelta from subclasses which only need to override
4075        MakeOneNeighbor().
4076        Therefore this method should not be overridden. Override MakeOneNeighbor()
4077        instead.
4078        """
4079        return _pywrapcp.IntVarLocalSearchOperator_NextNeighbor(self, delta, deltadelta)
4080
4081    def OneNeighbor(self):
4082        r"""
4083        Creates a new neighbor. It returns false when the neighborhood is
4084        completely explored.
4085        MakeNextNeighbor() in a subclass of IntVarLocalSearchOperator.
4086        """
4087        return _pywrapcp.IntVarLocalSearchOperator_OneNeighbor(self)
4088    def __disown__(self):
4089        self.this.disown()
4090        _pywrapcp.disown_IntVarLocalSearchOperator(self)
4091        return weakref.proxy(self)

Specialization of LocalSearchOperator built from an array of IntVars which specifies the scope of the operator. This class also takes care of storing current variable values in Start(), keeps track of changes done by the operator and builds the delta. The Deactivate() method can be used to perform Large Neighborhood Search.

IntVarLocalSearchOperator(vars, keep_inverse_values=False)
4007    def __init__(self, vars, keep_inverse_values=False):
4008        if self.__class__ == IntVarLocalSearchOperator:
4009            _self = None
4010        else:
4011            _self = self
4012        _pywrapcp.IntVarLocalSearchOperator_swiginit(self, _pywrapcp.new_IntVarLocalSearchOperator(_self, vars, keep_inverse_values))
thisown

The membership flag

def Start(self, assignment):
4015    def Start(self, assignment):
4016        r"""
4017        This method should not be overridden. Override OnStart() instead which is
4018        called before exiting this method.
4019        """
4020        return _pywrapcp.IntVarLocalSearchOperator_Start(self, assignment)

This method should not be overridden. Override OnStart() instead which is called before exiting this method.

def IsIncremental(self):
4022    def IsIncremental(self):
4023        return _pywrapcp.IntVarLocalSearchOperator_IsIncremental(self)
def Size(self):
4025    def Size(self):
4026        return _pywrapcp.IntVarLocalSearchOperator_Size(self)
def Value(self, index):
4028    def Value(self, index):
4029        r"""
4030        Returns the value in the current assignment of the variable of given
4031        index.
4032        """
4033        return _pywrapcp.IntVarLocalSearchOperator_Value(self, index)

Returns the value in the current assignment of the variable of given index.

def Var(self, index):
4035    def Var(self, index):
4036        r""" Returns the variable of given index."""
4037        return _pywrapcp.IntVarLocalSearchOperator_Var(self, index)

Returns the variable of given index.

def OldValue(self, index):
4039    def OldValue(self, index):
4040        return _pywrapcp.IntVarLocalSearchOperator_OldValue(self, index)
def PrevValue(self, index):
4042    def PrevValue(self, index):
4043        return _pywrapcp.IntVarLocalSearchOperator_PrevValue(self, index)
def SetValue(self, index, value):
4045    def SetValue(self, index, value):
4046        return _pywrapcp.IntVarLocalSearchOperator_SetValue(self, index, value)
def Activated(self, index):
4048    def Activated(self, index):
4049        return _pywrapcp.IntVarLocalSearchOperator_Activated(self, index)
def Activate(self, index):
4051    def Activate(self, index):
4052        return _pywrapcp.IntVarLocalSearchOperator_Activate(self, index)
def Deactivate(self, index):
4054    def Deactivate(self, index):
4055        return _pywrapcp.IntVarLocalSearchOperator_Deactivate(self, index)
def AddVars(self, vars):
4057    def AddVars(self, vars):
4058        return _pywrapcp.IntVarLocalSearchOperator_AddVars(self, vars)
def OnStart(self):
4060    def OnStart(self):
4061        r"""
4062        Called by Start() after synchronizing the operator with the current
4063        assignment. Should be overridden instead of Start() to avoid calling
4064        IntVarLocalSearchOperator::Start explicitly.
4065        """
4066        return _pywrapcp.IntVarLocalSearchOperator_OnStart(self)

Called by Start() after synchronizing the operator with the current assignment. Should be overridden instead of Start() to avoid calling IntVarLocalSearchOperator::Start explicitly.

def NextNeighbor(self, delta, deltadelta):
4068    def NextNeighbor(self, delta, deltadelta):
4069        r"""
4070        OnStart() should really be protected, but then SWIG doesn't see it. So we
4071        make it public, but only subclasses should access to it (to override it).
4072        Redefines MakeNextNeighbor to export a simpler interface. The calls to
4073        ApplyChanges() and RevertChanges() are factored in this method, hiding
4074        both delta and deltadelta from subclasses which only need to override
4075        MakeOneNeighbor().
4076        Therefore this method should not be overridden. Override MakeOneNeighbor()
4077        instead.
4078        """
4079        return _pywrapcp.IntVarLocalSearchOperator_NextNeighbor(self, delta, deltadelta)

OnStart() should really be protected, but then SWIG doesn't see it. So we make it public, but only subclasses should access to it (to override it). Redefines MakeNextNeighbor to export a simpler interface. The calls to ApplyChanges() and RevertChanges() are factored in this method, hiding both delta and deltadelta from subclasses which only need to override MakeOneNeighbor(). Therefore this method should not be overridden. Override MakeOneNeighbor() instead.

def OneNeighbor(self):
4081    def OneNeighbor(self):
4082        r"""
4083        Creates a new neighbor. It returns false when the neighborhood is
4084        completely explored.
4085        MakeNextNeighbor() in a subclass of IntVarLocalSearchOperator.
4086        """
4087        return _pywrapcp.IntVarLocalSearchOperator_OneNeighbor(self)

Creates a new neighbor. It returns false when the neighborhood is completely explored. MakeNextNeighbor() in a subclass of IntVarLocalSearchOperator.

Inherited Members
BaseObject
DebugString
class BaseLns(IntVarLocalSearchOperator):
4095class BaseLns(IntVarLocalSearchOperator):
4096    r"""
4097    This is the base class for building an Lns operator. An Lns fragment is a
4098    collection of variables which will be relaxed. Fragments are built with
4099    NextFragment(), which returns false if there are no more fragments to build.
4100    Optionally one can override InitFragments, which is called from
4101    LocalSearchOperator::Start to initialize fragment data.
4102
4103    Here's a sample relaxing one variable at a time:
4104
4105    class OneVarLns : public BaseLns {
4106     public:
4107      OneVarLns(const std::vector<IntVar*>& vars) : BaseLns(vars), index_(0) {}
4108      virtual ~OneVarLns() {}
4109      virtual void InitFragments() { index_ = 0; }
4110      virtual bool NextFragment() {
4111        const int size = Size();
4112        if (index_ < size) {
4113          AppendToFragment(index_);
4114          ++index_;
4115          return true;
4116        } else {
4117          return false;
4118        }
4119      }
4120
4121     private:
4122      int index_;
4123    };
4124    """
4125
4126    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4127    __repr__ = _swig_repr
4128
4129    def __init__(self, vars):
4130        if self.__class__ == BaseLns:
4131            _self = None
4132        else:
4133            _self = self
4134        _pywrapcp.BaseLns_swiginit(self, _pywrapcp.new_BaseLns(_self, vars))
4135    __swig_destroy__ = _pywrapcp.delete_BaseLns
4136
4137    def InitFragments(self):
4138        return _pywrapcp.BaseLns_InitFragments(self)
4139
4140    def NextFragment(self):
4141        return _pywrapcp.BaseLns_NextFragment(self)
4142
4143    def AppendToFragment(self, index):
4144        return _pywrapcp.BaseLns_AppendToFragment(self, index)
4145
4146    def FragmentSize(self):
4147        return _pywrapcp.BaseLns_FragmentSize(self)
4148
4149    def __getitem__(self, index):
4150        return _pywrapcp.BaseLns___getitem__(self, index)
4151
4152    def __len__(self):
4153        return _pywrapcp.BaseLns___len__(self)
4154    def __disown__(self):
4155        self.this.disown()
4156        _pywrapcp.disown_BaseLns(self)
4157        return weakref.proxy(self)

This is the base class for building an Lns operator. An Lns fragment is a collection of variables which will be relaxed. Fragments are built with NextFragment(), which returns false if there are no more fragments to build. Optionally one can override InitFragments, which is called from LocalSearchOperator::Start to initialize fragment data.

Here's a sample relaxing one variable at a time:

class OneVarLns : public BaseLns { public: OneVarLns(const std::vector& vars) : BaseLns(vars), index_(0) {} virtual ~OneVarLns() {} virtual void InitFragments() { index_ = 0; } virtual bool NextFragment() { const int size = Size(); if (index_ < size) { AppendToFragment(index_); ++index_; return true; } else { return false; } }

private: int index_; };

BaseLns(vars)
4129    def __init__(self, vars):
4130        if self.__class__ == BaseLns:
4131            _self = None
4132        else:
4133            _self = self
4134        _pywrapcp.BaseLns_swiginit(self, _pywrapcp.new_BaseLns(_self, vars))
thisown

The membership flag

def InitFragments(self):
4137    def InitFragments(self):
4138        return _pywrapcp.BaseLns_InitFragments(self)
def NextFragment(self):
4140    def NextFragment(self):
4141        return _pywrapcp.BaseLns_NextFragment(self)
def AppendToFragment(self, index):
4143    def AppendToFragment(self, index):
4144        return _pywrapcp.BaseLns_AppendToFragment(self, index)
def FragmentSize(self):
4146    def FragmentSize(self):
4147        return _pywrapcp.BaseLns_FragmentSize(self)
class ChangeValue(IntVarLocalSearchOperator):
4161class ChangeValue(IntVarLocalSearchOperator):
4162    r"""
4163    Defines operators which change the value of variables;
4164    each neighbor corresponds to *one* modified variable.
4165    Sub-classes have to define ModifyValue which determines what the new
4166    variable value is going to be (given the current value and the variable).
4167    """
4168
4169    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4170    __repr__ = _swig_repr
4171
4172    def __init__(self, vars):
4173        if self.__class__ == ChangeValue:
4174            _self = None
4175        else:
4176            _self = self
4177        _pywrapcp.ChangeValue_swiginit(self, _pywrapcp.new_ChangeValue(_self, vars))
4178    __swig_destroy__ = _pywrapcp.delete_ChangeValue
4179
4180    def ModifyValue(self, index, value):
4181        return _pywrapcp.ChangeValue_ModifyValue(self, index, value)
4182
4183    def OneNeighbor(self):
4184        r""" This method should not be overridden. Override ModifyValue() instead."""
4185        return _pywrapcp.ChangeValue_OneNeighbor(self)
4186    def __disown__(self):
4187        self.this.disown()
4188        _pywrapcp.disown_ChangeValue(self)
4189        return weakref.proxy(self)

Defines operators which change the value of variables; each neighbor corresponds to one modified variable. Sub-classes have to define ModifyValue which determines what the new variable value is going to be (given the current value and the variable).

ChangeValue(vars)
4172    def __init__(self, vars):
4173        if self.__class__ == ChangeValue:
4174            _self = None
4175        else:
4176            _self = self
4177        _pywrapcp.ChangeValue_swiginit(self, _pywrapcp.new_ChangeValue(_self, vars))
thisown

The membership flag

def ModifyValue(self, index, value):
4180    def ModifyValue(self, index, value):
4181        return _pywrapcp.ChangeValue_ModifyValue(self, index, value)
def OneNeighbor(self):
4183    def OneNeighbor(self):
4184        r""" This method should not be overridden. Override ModifyValue() instead."""
4185        return _pywrapcp.ChangeValue_OneNeighbor(self)

This method should not be overridden. Override ModifyValue() instead.

class PathOperator(IntVarLocalSearchOperator):
4193class PathOperator(IntVarLocalSearchOperator):
4194    r"""
4195    Base class of the local search operators dedicated to path modifications
4196    (a path is a set of nodes linked together by arcs).
4197    This family of neighborhoods supposes they are handling next variables
4198    representing the arcs (var[i] represents the node immediately after i on
4199    a path).
4200    Several services are provided:
4201    - arc manipulators (SetNext(), ReverseChain(), MoveChain())
4202    - path inspectors (Next(), Prev(), IsPathEnd())
4203    - path iterators: operators need a given number of nodes to define a
4204      neighbor; this class provides the iteration on a given number of (base)
4205      nodes which can be used to define a neighbor (through the BaseNode method)
4206    Subclasses only need to override MakeNeighbor to create neighbors using
4207    the services above (no direct manipulation of assignments).
4208    """
4209
4210    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4211
4212    def __init__(self, *args, **kwargs):
4213        raise AttributeError("No constructor defined - class is abstract")
4214    __repr__ = _swig_repr
4215
4216    def Neighbor(self):
4217        return _pywrapcp.PathOperator_Neighbor(self)

Base class of the local search operators dedicated to path modifications (a path is a set of nodes linked together by arcs). This family of neighborhoods supposes they are handling next variables representing the arcs (var[i] represents the node immediately after i on a path). Several services are provided:

  • arc manipulators (SetNext(), ReverseChain(), MoveChain())
  • path inspectors (Next(), Prev(), IsPathEnd())
  • path iterators: operators need a given number of nodes to define a neighbor; this class provides the iteration on a given number of (base) nodes which can be used to define a neighbor (through the BaseNode method) Subclasses only need to override MakeNeighbor to create neighbors using the services above (no direct manipulation of assignments).
PathOperator(*args, **kwargs)
4212    def __init__(self, *args, **kwargs):
4213        raise AttributeError("No constructor defined - class is abstract")
thisown

The membership flag

def Neighbor(self):
4216    def Neighbor(self):
4217        return _pywrapcp.PathOperator_Neighbor(self)
class LocalSearchFilter(BaseObject):
4221class LocalSearchFilter(BaseObject):
4222    r"""
4223    Classes to which this template function can be applied to as of 04/2014.
4224    Usage: LocalSearchOperator* op = MakeLocalSearchOperator<Relocate>(...);
4225    class TwoOpt;
4226    class Relocate;
4227    class Exchange;
4228    class Cross;
4229    class MakeActiveOperator;
4230    class MakeInactiveOperator;
4231    class MakeChainInactiveOperator;
4232    class SwapActiveOperator;
4233    class ExtendedSwapActiveOperator;
4234    class MakeActiveAndRelocate;
4235    class RelocateAndMakeActiveOperator;
4236    class RelocateAndMakeInactiveOperator;
4237    Local Search Filters are used for fast neighbor pruning.
4238    Filtering a move is done in several phases:
4239    - in the Relax phase, filters determine which parts of their internals
4240      will be changed by the candidate, and modify intermediary State
4241    - in the Accept phase, filters check that the candidate is feasible,
4242    - if the Accept phase succeeds, the solver may decide to trigger a
4243      Synchronize phase that makes filters change their internal representation
4244      to the last candidate,
4245    - otherwise (Accept fails or the solver does not want to synchronize),
4246      a Revert phase makes filters erase any intermediary State generated by the
4247      Relax and Accept phases.
4248    A given filter has phases called with the following pattern:
4249    (Relax.Accept.Synchronize | Relax.Accept.Revert | Relax.Revert)*.
4250    Filters's Revert() is always called in the reverse order their Accept() was
4251    called, to allow late filters to use state done/undone by early filters'
4252    Accept()/Revert().
4253    """
4254
4255    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4256
4257    def __init__(self, *args, **kwargs):
4258        raise AttributeError("No constructor defined - class is abstract")
4259    __repr__ = _swig_repr
4260
4261    def Accept(self, delta, deltadelta, objective_min, objective_max):
4262        r"""
4263        Accepts a "delta" given the assignment with which the filter has been
4264        synchronized; the delta holds the variables which have been modified and
4265        their new value.
4266        If the filter represents a part of the global objective, its contribution
4267        must be between objective_min and objective_max.
4268        Sample: supposing one wants to maintain a[0,1] + b[0,1] <= 1,
4269        for the assignment (a,1), (b,0), the delta (b,1) will be rejected
4270        but the delta (a,0) will be accepted.
4271        TODO(user): Remove arguments when there are no more need for those.
4272        """
4273        return _pywrapcp.LocalSearchFilter_Accept(self, delta, deltadelta, objective_min, objective_max)
4274
4275    def IsIncremental(self):
4276        return _pywrapcp.LocalSearchFilter_IsIncremental(self)
4277
4278    def Synchronize(self, assignment, delta):
4279        r"""
4280        Synchronizes the filter with the current solution, delta being the
4281        difference with the solution passed to the previous call to Synchronize()
4282        or IncrementalSynchronize(). 'delta' can be used to incrementally
4283        synchronizing the filter with the new solution by only considering the
4284        changes in delta.
4285        """
4286        return _pywrapcp.LocalSearchFilter_Synchronize(self, assignment, delta)
4287    __swig_destroy__ = _pywrapcp.delete_LocalSearchFilter

Classes to which this template function can be applied to as of 04/2014. Usage: LocalSearchOperator* op = MakeLocalSearchOperator(...); class TwoOpt; class Relocate; class Exchange; class Cross; class MakeActiveOperator; class MakeInactiveOperator; class MakeChainInactiveOperator; class SwapActiveOperator; class ExtendedSwapActiveOperator; class MakeActiveAndRelocate; class RelocateAndMakeActiveOperator; class RelocateAndMakeInactiveOperator; Local Search Filters are used for fast neighbor pruning. Filtering a move is done in several phases:

  • in the Relax phase, filters determine which parts of their internals will be changed by the candidate, and modify intermediary State
  • in the Accept phase, filters check that the candidate is feasible,
  • if the Accept phase succeeds, the solver may decide to trigger a Synchronize phase that makes filters change their internal representation to the last candidate,
  • otherwise (Accept fails or the solver does not want to synchronize), a Revert phase makes filters erase any intermediary State generated by the Relax and Accept phases. A given filter has phases called with the following pattern: (Relax.Accept.Synchronize | Relax.Accept.Revert | Relax.Revert)*. Filters's Revert() is always called in the reverse order their Accept() was called, to allow late filters to use state done/undone by early filters' Accept()/Revert().
LocalSearchFilter(*args, **kwargs)
4257    def __init__(self, *args, **kwargs):
4258        raise AttributeError("No constructor defined - class is abstract")
thisown

The membership flag

def Accept(self, delta, deltadelta, objective_min, objective_max):
4261    def Accept(self, delta, deltadelta, objective_min, objective_max):
4262        r"""
4263        Accepts a "delta" given the assignment with which the filter has been
4264        synchronized; the delta holds the variables which have been modified and
4265        their new value.
4266        If the filter represents a part of the global objective, its contribution
4267        must be between objective_min and objective_max.
4268        Sample: supposing one wants to maintain a[0,1] + b[0,1] <= 1,
4269        for the assignment (a,1), (b,0), the delta (b,1) will be rejected
4270        but the delta (a,0) will be accepted.
4271        TODO(user): Remove arguments when there are no more need for those.
4272        """
4273        return _pywrapcp.LocalSearchFilter_Accept(self, delta, deltadelta, objective_min, objective_max)

Accepts a "delta" given the assignment with which the filter has been synchronized; the delta holds the variables which have been modified and their new value. If the filter represents a part of the global objective, its contribution must be between objective_min and objective_max. Sample: supposing one wants to maintain a[0,1] + b[0,1] <= 1, for the assignment (a,1), (b,0), the delta (b,1) will be rejected but the delta (a,0) will be accepted. TODO(user): Remove arguments when there are no more need for those.

def IsIncremental(self):
4275    def IsIncremental(self):
4276        return _pywrapcp.LocalSearchFilter_IsIncremental(self)
def Synchronize(self, assignment, delta):
4278    def Synchronize(self, assignment, delta):
4279        r"""
4280        Synchronizes the filter with the current solution, delta being the
4281        difference with the solution passed to the previous call to Synchronize()
4282        or IncrementalSynchronize(). 'delta' can be used to incrementally
4283        synchronizing the filter with the new solution by only considering the
4284        changes in delta.
4285        """
4286        return _pywrapcp.LocalSearchFilter_Synchronize(self, assignment, delta)

Synchronizes the filter with the current solution, delta being the difference with the solution passed to the previous call to Synchronize() or IncrementalSynchronize(). 'delta' can be used to incrementally synchronizing the filter with the new solution by only considering the changes in delta.

Inherited Members
BaseObject
DebugString
class LocalSearchFilterManager(BaseObject):
4291class LocalSearchFilterManager(BaseObject):
4292    r"""
4293    Filter manager: when a move is made, filters are executed to decide whether
4294    the solution is feasible and compute parts of the new cost. This class
4295    schedules filter execution and composes costs as a sum.
4296    """
4297
4298    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4299    __repr__ = _swig_repr
4300
4301    def DebugString(self):
4302        return _pywrapcp.LocalSearchFilterManager_DebugString(self)
4303
4304    def __init__(self, *args):
4305        _pywrapcp.LocalSearchFilterManager_swiginit(self, _pywrapcp.new_LocalSearchFilterManager(*args))
4306
4307    def Accept(self, monitor, delta, deltadelta, objective_min, objective_max):
4308        r"""
4309        Returns true iff all filters return true, and the sum of their accepted
4310        objectives is between objective_min and objective_max.
4311        The monitor has its Begin/EndFiltering events triggered.
4312        """
4313        return _pywrapcp.LocalSearchFilterManager_Accept(self, monitor, delta, deltadelta, objective_min, objective_max)
4314
4315    def Synchronize(self, assignment, delta):
4316        r""" Synchronizes all filters to assignment."""
4317        return _pywrapcp.LocalSearchFilterManager_Synchronize(self, assignment, delta)
4318    __swig_destroy__ = _pywrapcp.delete_LocalSearchFilterManager

Filter manager: when a move is made, filters are executed to decide whether the solution is feasible and compute parts of the new cost. This class schedules filter execution and composes costs as a sum.

LocalSearchFilterManager(*args)
4304    def __init__(self, *args):
4305        _pywrapcp.LocalSearchFilterManager_swiginit(self, _pywrapcp.new_LocalSearchFilterManager(*args))
thisown

The membership flag

def DebugString(self):
4301    def DebugString(self):
4302        return _pywrapcp.LocalSearchFilterManager_DebugString(self)
def Accept(self, monitor, delta, deltadelta, objective_min, objective_max):
4307    def Accept(self, monitor, delta, deltadelta, objective_min, objective_max):
4308        r"""
4309        Returns true iff all filters return true, and the sum of their accepted
4310        objectives is between objective_min and objective_max.
4311        The monitor has its Begin/EndFiltering events triggered.
4312        """
4313        return _pywrapcp.LocalSearchFilterManager_Accept(self, monitor, delta, deltadelta, objective_min, objective_max)

Returns true iff all filters return true, and the sum of their accepted objectives is between objective_min and objective_max. The monitor has its Begin/EndFiltering events triggered.

def Synchronize(self, assignment, delta):
4315    def Synchronize(self, assignment, delta):
4316        r""" Synchronizes all filters to assignment."""
4317        return _pywrapcp.LocalSearchFilterManager_Synchronize(self, assignment, delta)

Synchronizes all filters to assignment.

class IntVarLocalSearchFilter(LocalSearchFilter):
4322class IntVarLocalSearchFilter(LocalSearchFilter):
4323    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4324    __repr__ = _swig_repr
4325
4326    def __init__(self, vars):
4327        if self.__class__ == IntVarLocalSearchFilter:
4328            _self = None
4329        else:
4330            _self = self
4331        _pywrapcp.IntVarLocalSearchFilter_swiginit(self, _pywrapcp.new_IntVarLocalSearchFilter(_self, vars))
4332    __swig_destroy__ = _pywrapcp.delete_IntVarLocalSearchFilter
4333
4334    def Synchronize(self, assignment, delta):
4335        r"""
4336        This method should not be overridden. Override OnSynchronize() instead
4337        which is called before exiting this method.
4338        """
4339        return _pywrapcp.IntVarLocalSearchFilter_Synchronize(self, assignment, delta)
4340
4341    def Size(self):
4342        return _pywrapcp.IntVarLocalSearchFilter_Size(self)
4343
4344    def Value(self, index):
4345        return _pywrapcp.IntVarLocalSearchFilter_Value(self, index)
4346
4347    def IndexFromVar(self, var):
4348        return _pywrapcp.IntVarLocalSearchFilter_IndexFromVar(self, var)
4349    def __disown__(self):
4350        self.this.disown()
4351        _pywrapcp.disown_IntVarLocalSearchFilter(self)
4352        return weakref.proxy(self)

Classes to which this template function can be applied to as of 04/2014. Usage: LocalSearchOperator* op = MakeLocalSearchOperator(...); class TwoOpt; class Relocate; class Exchange; class Cross; class MakeActiveOperator; class MakeInactiveOperator; class MakeChainInactiveOperator; class SwapActiveOperator; class ExtendedSwapActiveOperator; class MakeActiveAndRelocate; class RelocateAndMakeActiveOperator; class RelocateAndMakeInactiveOperator; Local Search Filters are used for fast neighbor pruning. Filtering a move is done in several phases:

  • in the Relax phase, filters determine which parts of their internals will be changed by the candidate, and modify intermediary State
  • in the Accept phase, filters check that the candidate is feasible,
  • if the Accept phase succeeds, the solver may decide to trigger a Synchronize phase that makes filters change their internal representation to the last candidate,
  • otherwise (Accept fails or the solver does not want to synchronize), a Revert phase makes filters erase any intermediary State generated by the Relax and Accept phases. A given filter has phases called with the following pattern: (Relax.Accept.Synchronize | Relax.Accept.Revert | Relax.Revert)*. Filters's Revert() is always called in the reverse order their Accept() was called, to allow late filters to use state done/undone by early filters' Accept()/Revert().
IntVarLocalSearchFilter(vars)
4326    def __init__(self, vars):
4327        if self.__class__ == IntVarLocalSearchFilter:
4328            _self = None
4329        else:
4330            _self = self
4331        _pywrapcp.IntVarLocalSearchFilter_swiginit(self, _pywrapcp.new_IntVarLocalSearchFilter(_self, vars))
thisown

The membership flag

def Synchronize(self, assignment, delta):
4334    def Synchronize(self, assignment, delta):
4335        r"""
4336        This method should not be overridden. Override OnSynchronize() instead
4337        which is called before exiting this method.
4338        """
4339        return _pywrapcp.IntVarLocalSearchFilter_Synchronize(self, assignment, delta)

This method should not be overridden. Override OnSynchronize() instead which is called before exiting this method.

def Size(self):
4341    def Size(self):
4342        return _pywrapcp.IntVarLocalSearchFilter_Size(self)
def Value(self, index):
4344    def Value(self, index):
4345        return _pywrapcp.IntVarLocalSearchFilter_Value(self, index)
def IndexFromVar(self, var):
4347    def IndexFromVar(self, var):
4348        return _pywrapcp.IntVarLocalSearchFilter_IndexFromVar(self, var)
class BooleanVar(IntVar):
4356class BooleanVar(IntVar):
4357    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4358
4359    def __init__(self, *args, **kwargs):
4360        raise AttributeError("No constructor defined - class is abstract")
4361    __repr__ = _swig_repr
4362
4363    def Min(self):
4364        return _pywrapcp.BooleanVar_Min(self)
4365
4366    def SetMin(self, m):
4367        return _pywrapcp.BooleanVar_SetMin(self, m)
4368
4369    def Max(self):
4370        return _pywrapcp.BooleanVar_Max(self)
4371
4372    def SetMax(self, m):
4373        return _pywrapcp.BooleanVar_SetMax(self, m)
4374
4375    def SetRange(self, mi, ma):
4376        return _pywrapcp.BooleanVar_SetRange(self, mi, ma)
4377
4378    def Bound(self):
4379        return _pywrapcp.BooleanVar_Bound(self)
4380
4381    def Value(self):
4382        return _pywrapcp.BooleanVar_Value(self)
4383
4384    def RemoveValue(self, v):
4385        return _pywrapcp.BooleanVar_RemoveValue(self, v)
4386
4387    def RemoveInterval(self, l, u):
4388        return _pywrapcp.BooleanVar_RemoveInterval(self, l, u)
4389
4390    def WhenBound(self, d):
4391        return _pywrapcp.BooleanVar_WhenBound(self, d)
4392
4393    def WhenRange(self, d):
4394        return _pywrapcp.BooleanVar_WhenRange(self, d)
4395
4396    def WhenDomain(self, d):
4397        return _pywrapcp.BooleanVar_WhenDomain(self, d)
4398
4399    def Size(self):
4400        return _pywrapcp.BooleanVar_Size(self)
4401
4402    def Contains(self, v):
4403        return _pywrapcp.BooleanVar_Contains(self, v)
4404
4405    def HoleIteratorAux(self, reversible):
4406        return _pywrapcp.BooleanVar_HoleIteratorAux(self, reversible)
4407
4408    def DomainIteratorAux(self, reversible):
4409        return _pywrapcp.BooleanVar_DomainIteratorAux(self, reversible)
4410
4411    def DebugString(self):
4412        return _pywrapcp.BooleanVar_DebugString(self)

The class IntVar is a subset of IntExpr. In addition to the IntExpr protocol, it offers persistence, removing values from the domains, and a finer model for events.

BooleanVar(*args, **kwargs)
4359    def __init__(self, *args, **kwargs):
4360        raise AttributeError("No constructor defined - class is abstract")
thisown

The membership flag

def Min(self):
4363    def Min(self):
4364        return _pywrapcp.BooleanVar_Min(self)
def SetMin(self, m):
4366    def SetMin(self, m):
4367        return _pywrapcp.BooleanVar_SetMin(self, m)
def Max(self):
4369    def Max(self):
4370        return _pywrapcp.BooleanVar_Max(self)
def SetMax(self, m):
4372    def SetMax(self, m):
4373        return _pywrapcp.BooleanVar_SetMax(self, m)
def SetRange(self, mi, ma):
4375    def SetRange(self, mi, ma):
4376        return _pywrapcp.BooleanVar_SetRange(self, mi, ma)

This method sets both the min and the max of the expression.

def Bound(self):
4378    def Bound(self):
4379        return _pywrapcp.BooleanVar_Bound(self)

Returns true if the min and the max of the expression are equal.

def Value(self):
4381    def Value(self):
4382        return _pywrapcp.BooleanVar_Value(self)

This method returns the value of the variable. This method checks before that the variable is bound.

def RemoveValue(self, v):
4384    def RemoveValue(self, v):
4385        return _pywrapcp.BooleanVar_RemoveValue(self, v)

This method removes the value 'v' from the domain of the variable.

def RemoveInterval(self, l, u):
4387    def RemoveInterval(self, l, u):
4388        return _pywrapcp.BooleanVar_RemoveInterval(self, l, u)

This method removes the interval 'l' .. 'u' from the domain of the variable. It assumes that 'l' <= 'u'.

def WhenBound(self, d):
4390    def WhenBound(self, d):
4391        return _pywrapcp.BooleanVar_WhenBound(self, d)

Overload 1: This method attaches a demon that will be awakened when the variable is bound.

|

Overload 2: This method attaches a closure that will be awakened when the variable is bound.

def WhenRange(self, d):
4393    def WhenRange(self, d):
4394        return _pywrapcp.BooleanVar_WhenRange(self, d)

Overload 1: Attach a demon that will watch the min or the max of the expression.

|

Overload 2: Attach a demon that will watch the min or the max of the expression.

def WhenDomain(self, d):
4396    def WhenDomain(self, d):
4397        return _pywrapcp.BooleanVar_WhenDomain(self, d)

Overload 1: This method attaches a demon that will watch any domain modification of the domain of the variable.

|

Overload 2: This method attaches a closure that will watch any domain modification of the domain of the variable.

def Size(self):
4399    def Size(self):
4400        return _pywrapcp.BooleanVar_Size(self)

This method returns the number of values in the domain of the variable.

def Contains(self, v):
4402    def Contains(self, v):
4403        return _pywrapcp.BooleanVar_Contains(self, v)

This method returns whether the value 'v' is in the domain of the variable.

def HoleIteratorAux(self, reversible):
4405    def HoleIteratorAux(self, reversible):
4406        return _pywrapcp.BooleanVar_HoleIteratorAux(self, reversible)

Creates a hole iterator. When 'reversible' is false, the returned object is created on the normal C++ heap and the solver does NOT take ownership of the object.

def DomainIteratorAux(self, reversible):
4408    def DomainIteratorAux(self, reversible):
4409        return _pywrapcp.BooleanVar_DomainIteratorAux(self, reversible)

Creates a domain iterator. When 'reversible' is false, the returned object is created on the normal C++ heap and the solver does NOT take ownership of the object.

def DebugString(self):
4411    def DebugString(self):
4412        return _pywrapcp.BooleanVar_DebugString(self)
class PyDecision(Decision):
4417class PyDecision(Decision):
4418
4419  def __init__(self):
4420    Decision.__init__(self)
4421
4422  def ApplyWrapper(self, solver):
4423    try:
4424       self.Apply(solver)
4425    except Exception as e:
4426      if 'CP Solver fail' in str(e):
4427        solver.ShouldFail()
4428      else:
4429        raise
4430
4431  def RefuteWrapper(self, solver):
4432    try:
4433       self.Refute(solver)
4434    except Exception as e:
4435      if 'CP Solver fail' in str(e):
4436        solver.ShouldFail()
4437      else:
4438        raise
4439
4440  def DebugString(self):
4441    return "PyDecision"

A Decision represents a choice point in the search tree. The two main methods are Apply() to go left, or Refute() to go right.

def ApplyWrapper(self, solver):
4422  def ApplyWrapper(self, solver):
4423    try:
4424       self.Apply(solver)
4425    except Exception as e:
4426      if 'CP Solver fail' in str(e):
4427        solver.ShouldFail()
4428      else:
4429        raise

Apply will be called first when the decision is executed.

def RefuteWrapper(self, solver):
4431  def RefuteWrapper(self, solver):
4432    try:
4433       self.Refute(solver)
4434    except Exception as e:
4435      if 'CP Solver fail' in str(e):
4436        solver.ShouldFail()
4437      else:
4438        raise

Refute will be called after a backtrack.

def DebugString(self):
4440  def DebugString(self):
4441    return "PyDecision"
Inherited Members
Decision
thisown
class PyDecisionBuilder(DecisionBuilder):
4444class PyDecisionBuilder(DecisionBuilder):
4445
4446  def __init__(self):
4447    DecisionBuilder.__init__(self)
4448
4449  def NextWrapper(self, solver):
4450    try:
4451      return self.Next(solver)
4452    except Exception as e:
4453      if 'CP Solver fail' in str(e):
4454        return solver.FailDecision()
4455      else:
4456        raise
4457
4458  def DebugString(self):
4459    return "PyDecisionBuilder"

A DecisionBuilder is responsible for creating the search tree. The important method is Next(), which returns the next decision to execute.

def NextWrapper(self, solver):
4449  def NextWrapper(self, solver):
4450    try:
4451      return self.Next(solver)
4452    except Exception as e:
4453      if 'CP Solver fail' in str(e):
4454        return solver.FailDecision()
4455      else:
4456        raise

This is the main method of the decision builder class. It must return a decision (an instance of the class Decision). If it returns nullptr, this means that the decision builder has finished its work.

def DebugString(self):
4458  def DebugString(self):
4459    return "PyDecisionBuilder"
Inherited Members
DecisionBuilder
thisown
class PyDemon(Demon):
4462class PyDemon(Demon):
4463
4464  def RunWrapper(self, solver):
4465    try:
4466      self.Run(solver)
4467    except Exception as e:
4468      if 'CP Solver fail' in str(e):
4469        solver.ShouldFail()
4470      else:
4471        raise
4472
4473  def DebugString(self):
4474    return "PyDemon"

A Demon is the base element of a propagation queue. It is the main object responsible for implementing the actual propagation of the constraint and pruning the inconsistent values in the domains of the variables. The main concept is that demons are listeners that are attached to the variables and listen to their modifications.

There are two methods:
  • Run() is the actual method called when the demon is processed.
  • priority() returns its priority. Standard priorities are slow, normal or fast. "immediate" is reserved for variables and is treated separately.
def RunWrapper(self, solver):
4464  def RunWrapper(self, solver):
4465    try:
4466      self.Run(solver)
4467    except Exception as e:
4468      if 'CP Solver fail' in str(e):
4469        solver.ShouldFail()
4470      else:
4471        raise

This is the main callback of the demon.

def DebugString(self):
4473  def DebugString(self):
4474    return "PyDemon"
class PyConstraintDemon(PyDemon):
4477class PyConstraintDemon(PyDemon):
4478
4479  def __init__(self, ct, method, delayed, *args):
4480    PyDemon.__init__(self)
4481    self.__constraint = ct
4482    self.__method = method
4483    self.__delayed = delayed
4484    self.__args = args
4485
4486  def Run(self, solver):
4487    self.__method(self.__constraint, *self.__args)
4488
4489  def Priority(self):
4490    return Solver.DELAYED_PRIORITY if self.__delayed else Solver.NORMAL_PRIORITY
4491
4492  def DebugString(self):
4493    return 'PyConstraintDemon'

A Demon is the base element of a propagation queue. It is the main object responsible for implementing the actual propagation of the constraint and pruning the inconsistent values in the domains of the variables. The main concept is that demons are listeners that are attached to the variables and listen to their modifications.

There are two methods:
  • Run() is the actual method called when the demon is processed.
  • priority() returns its priority. Standard priorities are slow, normal or fast. "immediate" is reserved for variables and is treated separately.
PyConstraintDemon(ct, method, delayed, *args)
4479  def __init__(self, ct, method, delayed, *args):
4480    PyDemon.__init__(self)
4481    self.__constraint = ct
4482    self.__method = method
4483    self.__delayed = delayed
4484    self.__args = args

This indicates the priority of a demon. Immediate demons are treated separately and corresponds to variables.

def Run(self, solver):
4486  def Run(self, solver):
4487    self.__method(self.__constraint, *self.__args)
def Priority(self):
4489  def Priority(self):
4490    return Solver.DELAYED_PRIORITY if self.__delayed else Solver.NORMAL_PRIORITY

This method returns the priority of the demon. Usually a demon is fast, slow or normal. Immediate demons are reserved for internal use to maintain variables.

def DebugString(self):
4492  def DebugString(self):
4493    return 'PyConstraintDemon'
class PyConstraint(Constraint):
4496class PyConstraint(Constraint):
4497
4498  def __init__(self, solver):
4499    Constraint.__init__(self, solver)
4500    self.__demons = []
4501
4502  def Demon(self, method, *args):
4503    demon = PyConstraintDemon(self, method, False, *args)
4504    self.__demons.append(demon)
4505    return demon
4506
4507  def DelayedDemon(self, method, *args):
4508    demon = PyConstraintDemon(self, method, True, *args)
4509    self.__demons.append(demon)
4510    return demon
4511
4512  def InitialPropagateDemon(self):
4513    return self.solver().ConstraintInitialPropagateCallback(self)
4514
4515  def DelayedInitialPropagateDemon(self):
4516    return self.solver().DelayedConstraintInitialPropagateCallback(self)
4517
4518  def InitialPropagateWrapper(self):
4519    try:
4520      self.InitialPropagate()
4521    except Exception as e:
4522      if 'CP Solver fail' in str(e):
4523        self.solver().ShouldFail()
4524      else:
4525        raise
4526
4527  def DebugString(self):
4528    return "PyConstraint"

A constraint is the main modeling object. It provides two methods:

  • Post() is responsible for creating the demons and attaching them to immediate demons().
  • InitialPropagate() is called once just after Post and performs the initial propagation. The subsequent propagations will be performed by the demons Posted during the post() method.
PyConstraint(solver)
4498  def __init__(self, solver):
4499    Constraint.__init__(self, solver)
4500    self.__demons = []
def Demon(self, method, *args):
4502  def Demon(self, method, *args):
4503    demon = PyConstraintDemon(self, method, False, *args)
4504    self.__demons.append(demon)
4505    return demon
def DelayedDemon(self, method, *args):
4507  def DelayedDemon(self, method, *args):
4508    demon = PyConstraintDemon(self, method, True, *args)
4509    self.__demons.append(demon)
4510    return demon
def InitialPropagateDemon(self):
4512  def InitialPropagateDemon(self):
4513    return self.solver().ConstraintInitialPropagateCallback(self)
def DelayedInitialPropagateDemon(self):
4515  def DelayedInitialPropagateDemon(self):
4516    return self.solver().DelayedConstraintInitialPropagateCallback(self)
def InitialPropagateWrapper(self):
4518  def InitialPropagateWrapper(self):
4519    try:
4520      self.InitialPropagate()
4521    except Exception as e:
4522      if 'CP Solver fail' in str(e):
4523        self.solver().ShouldFail()
4524      else:
4525        raise

This method performs the initial propagation of the constraint. It is called just after the post.

def DebugString(self):
4527  def DebugString(self):
4528    return "PyConstraint"
class RoutingIndexManager:
4532class RoutingIndexManager(object):
4533    r"""
4534    Manager for any NodeIndex <-> variable index conversion. The routing solver
4535    uses variable indices internally and through its API. These variable indices
4536    are tricky to manage directly because one Node can correspond to a multitude
4537    of variables, depending on the number of times they appear in the model, and
4538    if they're used as start and/or end points. This class aims to simplify
4539    variable index usage, allowing users to use NodeIndex instead.
4540
4541    Usage:
4542
4543      .. code-block:: c++
4544
4545          auto starts_ends = ...;  /// These are NodeIndex.
4546          RoutingIndexManager manager(10, 4, starts_ends);  // 10 nodes, 4 vehicles.
4547          RoutingModel model(manager);
4548
4549    Then, use 'manager.NodeToIndex(node)' whenever model requires a variable
4550    index.
4551
4552    Note: the mapping between node indices and variables indices is subject to
4553    change so no assumption should be made on it. The only guarantee is that
4554    indices range between 0 and n-1, where n = number of vehicles * 2 (for start
4555    and end nodes) + number of non-start or end nodes.
4556    """
4557
4558    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4559    __repr__ = _swig_repr
4560
4561    def __init__(self, *args):
4562        _pywrapcp.RoutingIndexManager_swiginit(self, _pywrapcp.new_RoutingIndexManager(*args))
4563
4564    def GetNumberOfNodes(self):
4565        return _pywrapcp.RoutingIndexManager_GetNumberOfNodes(self)
4566
4567    def GetNumberOfVehicles(self):
4568        return _pywrapcp.RoutingIndexManager_GetNumberOfVehicles(self)
4569
4570    def GetNumberOfIndices(self):
4571        return _pywrapcp.RoutingIndexManager_GetNumberOfIndices(self)
4572
4573    def GetStartIndex(self, vehicle):
4574        return _pywrapcp.RoutingIndexManager_GetStartIndex(self, vehicle)
4575
4576    def GetEndIndex(self, vehicle):
4577        return _pywrapcp.RoutingIndexManager_GetEndIndex(self, vehicle)
4578
4579    def NodeToIndex(self, node):
4580        return _pywrapcp.RoutingIndexManager_NodeToIndex(self, node)
4581
4582    def IndexToNode(self, index):
4583        return _pywrapcp.RoutingIndexManager_IndexToNode(self, index)
4584    __swig_destroy__ = _pywrapcp.delete_RoutingIndexManager

Manager for any NodeIndex <-> variable index conversion. The routing solver uses variable indices internally and through its API. These variable indices are tricky to manage directly because one Node can correspond to a multitude of variables, depending on the number of times they appear in the model, and if they're used as start and/or end points. This class aims to simplify variable index usage, allowing users to use NodeIndex instead.

Usage:

.. code-block:: c++

auto starts_ends = ...;  /// These are NodeIndex.
RoutingIndexManager manager(10, 4, starts_ends);  // 10 nodes, 4 vehicles.
RoutingModel model(manager);

Then, use 'manager.NodeToIndex(node)' whenever model requires a variable index.

Note: the mapping between node indices and variables indices is subject to change so no assumption should be made on it. The only guarantee is that indices range between 0 and n-1, where n = number of vehicles * 2 (for start and end nodes) + number of non-start or end nodes.

RoutingIndexManager(*args)
4561    def __init__(self, *args):
4562        _pywrapcp.RoutingIndexManager_swiginit(self, _pywrapcp.new_RoutingIndexManager(*args))
thisown

The membership flag

def GetNumberOfNodes(self):
4564    def GetNumberOfNodes(self):
4565        return _pywrapcp.RoutingIndexManager_GetNumberOfNodes(self)
def GetNumberOfVehicles(self):
4567    def GetNumberOfVehicles(self):
4568        return _pywrapcp.RoutingIndexManager_GetNumberOfVehicles(self)
def GetNumberOfIndices(self):
4570    def GetNumberOfIndices(self):
4571        return _pywrapcp.RoutingIndexManager_GetNumberOfIndices(self)
def GetStartIndex(self, vehicle):
4573    def GetStartIndex(self, vehicle):
4574        return _pywrapcp.RoutingIndexManager_GetStartIndex(self, vehicle)
def GetEndIndex(self, vehicle):
4576    def GetEndIndex(self, vehicle):
4577        return _pywrapcp.RoutingIndexManager_GetEndIndex(self, vehicle)
def NodeToIndex(self, node):
4579    def NodeToIndex(self, node):
4580        return _pywrapcp.RoutingIndexManager_NodeToIndex(self, node)
def IndexToNode(self, index):
4582    def IndexToNode(self, index):
4583        return _pywrapcp.RoutingIndexManager_IndexToNode(self, index)
def DefaultRoutingModelParameters():
4589def DefaultRoutingModelParameters():
4590    return _pywrapcp.DefaultRoutingModelParameters()
def DefaultRoutingSearchParameters():
4592def DefaultRoutingSearchParameters():
4593    return _pywrapcp.DefaultRoutingSearchParameters()
def FindErrorInRoutingSearchParameters(search_parameters):
4595def FindErrorInRoutingSearchParameters(search_parameters):
4596    r"""
4597    Returns an empty std::string if the routing search parameters are valid, and
4598    a non-empty, human readable error description if they're not.
4599    """
4600    return _pywrapcp.FindErrorInRoutingSearchParameters(search_parameters)

Returns an empty std::string if the routing search parameters are valid, and a non-empty, human readable error description if they're not.

BOOL_UNSPECIFIED = 0
BOOL_FALSE = 2
BOOL_TRUE = 3
class FirstSolutionStrategy:
4604class FirstSolutionStrategy(object):
4605    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4606    __repr__ = _swig_repr
4607
4608    def __init__(self):
4609        _pywrapcp.FirstSolutionStrategy_swiginit(self, _pywrapcp.new_FirstSolutionStrategy())
4610    __swig_destroy__ = _pywrapcp.delete_FirstSolutionStrategy
thisown

The membership flag

class LocalSearchMetaheuristic:
4614class LocalSearchMetaheuristic(object):
4615    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4616    __repr__ = _swig_repr
4617
4618    def __init__(self):
4619        _pywrapcp.LocalSearchMetaheuristic_swiginit(self, _pywrapcp.new_LocalSearchMetaheuristic())
4620    __swig_destroy__ = _pywrapcp.delete_LocalSearchMetaheuristic
thisown

The membership flag

class PathsMetadata:
4624class PathsMetadata(object):
4625    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4626    __repr__ = _swig_repr
4627
4628    def __init__(self, manager):
4629        _pywrapcp.PathsMetadata_swiginit(self, _pywrapcp.new_PathsMetadata(manager))
4630
4631    def IsStart(self, node):
4632        return _pywrapcp.PathsMetadata_IsStart(self, node)
4633
4634    def IsEnd(self, node):
4635        return _pywrapcp.PathsMetadata_IsEnd(self, node)
4636
4637    def GetPath(self, start_or_end_node):
4638        return _pywrapcp.PathsMetadata_GetPath(self, start_or_end_node)
4639
4640    def NumPaths(self):
4641        return _pywrapcp.PathsMetadata_NumPaths(self)
4642
4643    def Paths(self):
4644        return _pywrapcp.PathsMetadata_Paths(self)
4645
4646    def Starts(self):
4647        return _pywrapcp.PathsMetadata_Starts(self)
4648
4649    def Ends(self):
4650        return _pywrapcp.PathsMetadata_Ends(self)
4651    __swig_destroy__ = _pywrapcp.delete_PathsMetadata
PathsMetadata(manager)
4628    def __init__(self, manager):
4629        _pywrapcp.PathsMetadata_swiginit(self, _pywrapcp.new_PathsMetadata(manager))
thisown

The membership flag

def IsStart(self, node):
4631    def IsStart(self, node):
4632        return _pywrapcp.PathsMetadata_IsStart(self, node)
def IsEnd(self, node):
4634    def IsEnd(self, node):
4635        return _pywrapcp.PathsMetadata_IsEnd(self, node)
def GetPath(self, start_or_end_node):
4637    def GetPath(self, start_or_end_node):
4638        return _pywrapcp.PathsMetadata_GetPath(self, start_or_end_node)
def NumPaths(self):
4640    def NumPaths(self):
4641        return _pywrapcp.PathsMetadata_NumPaths(self)
def Paths(self):
4643    def Paths(self):
4644        return _pywrapcp.PathsMetadata_Paths(self)
def Starts(self):
4646    def Starts(self):
4647        return _pywrapcp.PathsMetadata_Starts(self)
def Ends(self):
4649    def Ends(self):
4650        return _pywrapcp.PathsMetadata_Ends(self)
class RoutingModel:
4655class RoutingModel(object):
4656    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
4657    __repr__ = _swig_repr
4658    ROUTING_NOT_SOLVED = _pywrapcp.RoutingModel_ROUTING_NOT_SOLVED
4659    r""" Problem not solved yet (before calling RoutingModel::Solve())."""
4660    ROUTING_SUCCESS = _pywrapcp.RoutingModel_ROUTING_SUCCESS
4661    r""" Problem solved successfully after calling RoutingModel::Solve()."""
4662    ROUTING_PARTIAL_SUCCESS_LOCAL_OPTIMUM_NOT_REACHED = _pywrapcp.RoutingModel_ROUTING_PARTIAL_SUCCESS_LOCAL_OPTIMUM_NOT_REACHED
4663    r"""
4664    Problem solved successfully after calling RoutingModel::Solve(), except
4665    that a local optimum has not been reached. Leaving more time would allow
4666    improving the solution.
4667    """
4668    ROUTING_FAIL = _pywrapcp.RoutingModel_ROUTING_FAIL
4669    r""" No solution found to the problem after calling RoutingModel::Solve()."""
4670    ROUTING_FAIL_TIMEOUT = _pywrapcp.RoutingModel_ROUTING_FAIL_TIMEOUT
4671    r""" Time limit reached before finding a solution with RoutingModel::Solve()."""
4672    ROUTING_INVALID = _pywrapcp.RoutingModel_ROUTING_INVALID
4673    r""" Model, model parameters or flags are not valid."""
4674    ROUTING_INFEASIBLE = _pywrapcp.RoutingModel_ROUTING_INFEASIBLE
4675    r""" Problem proven to be infeasible."""
4676    PICKUP_AND_DELIVERY_NO_ORDER = _pywrapcp.RoutingModel_PICKUP_AND_DELIVERY_NO_ORDER
4677    r""" Any precedence is accepted."""
4678    PICKUP_AND_DELIVERY_LIFO = _pywrapcp.RoutingModel_PICKUP_AND_DELIVERY_LIFO
4679    r""" Deliveries must be performed in reverse order of pickups."""
4680    PICKUP_AND_DELIVERY_FIFO = _pywrapcp.RoutingModel_PICKUP_AND_DELIVERY_FIFO
4681    r""" Deliveries must be performed in the same order as pickups."""
4682
4683    def __init__(self, *args):
4684        _pywrapcp.RoutingModel_swiginit(self, _pywrapcp.new_RoutingModel(*args))
4685    __swig_destroy__ = _pywrapcp.delete_RoutingModel
4686    kTransitEvaluatorSignUnknown = _pywrapcp.RoutingModel_kTransitEvaluatorSignUnknown
4687    kTransitEvaluatorSignPositiveOrZero = _pywrapcp.RoutingModel_kTransitEvaluatorSignPositiveOrZero
4688    kTransitEvaluatorSignNegativeOrZero = _pywrapcp.RoutingModel_kTransitEvaluatorSignNegativeOrZero
4689
4690    def RegisterUnaryTransitVector(self, values):
4691        r"""
4692        Registers 'callback' and returns its index.
4693        The sign parameter allows to notify the solver that the callback only
4694        return values of the given sign. This can help the solver, but passing
4695        an incorrect sign may crash in non-opt compilation mode, and yield
4696        incorrect results in opt.
4697        """
4698        return _pywrapcp.RoutingModel_RegisterUnaryTransitVector(self, values)
4699
4700    def RegisterUnaryTransitCallback(self, *args):
4701        return _pywrapcp.RoutingModel_RegisterUnaryTransitCallback(self, *args)
4702
4703    def RegisterTransitMatrix(self, values):
4704        return _pywrapcp.RoutingModel_RegisterTransitMatrix(self, values)
4705
4706    def RegisterTransitCallback(self, *args):
4707        return _pywrapcp.RoutingModel_RegisterTransitCallback(self, *args)
4708
4709    def TransitCallback(self, callback_index):
4710        return _pywrapcp.RoutingModel_TransitCallback(self, callback_index)
4711
4712    def UnaryTransitCallbackOrNull(self, callback_index):
4713        return _pywrapcp.RoutingModel_UnaryTransitCallbackOrNull(self, callback_index)
4714
4715    def AddDimension(self, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name):
4716        r"""
4717        Model creation
4718        Methods to add dimensions to routes; dimensions represent quantities
4719        accumulated at nodes along the routes. They represent quantities such as
4720        weights or volumes carried along the route, or distance or times.
4721        Quantities at a node are represented by "cumul" variables and the increase
4722        or decrease of quantities between nodes are represented by "transit"
4723        variables. These variables are linked as follows:
4724        if j == next(i), cumul(j) = cumul(i) + transit(i, j) + slack(i)
4725        where slack is a positive slack variable (can represent waiting times for
4726        a time dimension).
4727        Setting the value of fix_start_cumul_to_zero to true will force the
4728        "cumul" variable of the start node of all vehicles to be equal to 0.
4729        Creates a dimension where the transit variable is constrained to be
4730        equal to evaluator(i, next(i)); 'slack_max' is the upper bound of the
4731        slack variable and 'capacity' is the upper bound of the cumul variables.
4732        'name' is the name used to reference the dimension; this name is used to
4733        get cumul and transit variables from the routing model.
4734        Returns false if a dimension with the same name has already been created
4735        (and doesn't create the new dimension).
4736        Takes ownership of the callback 'evaluator'.
4737        """
4738        return _pywrapcp.RoutingModel_AddDimension(self, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name)
4739
4740    def AddDimensionWithVehicleTransits(self, evaluator_indices, slack_max, capacity, fix_start_cumul_to_zero, name):
4741        return _pywrapcp.RoutingModel_AddDimensionWithVehicleTransits(self, evaluator_indices, slack_max, capacity, fix_start_cumul_to_zero, name)
4742
4743    def AddDimensionWithVehicleCapacity(self, evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name):
4744        return _pywrapcp.RoutingModel_AddDimensionWithVehicleCapacity(self, evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name)
4745
4746    def AddDimensionWithVehicleTransitAndCapacity(self, evaluator_indices, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name):
4747        return _pywrapcp.RoutingModel_AddDimensionWithVehicleTransitAndCapacity(self, evaluator_indices, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name)
4748
4749    def AddConstantDimensionWithSlack(self, value, capacity, slack_max, fix_start_cumul_to_zero, name):
4750        r"""
4751        Creates a dimension where the transit variable is constrained to be
4752        equal to 'value'; 'capacity' is the upper bound of the cumul variables.
4753        'name' is the name used to reference the dimension; this name is used to
4754        get cumul and transit variables from the routing model.
4755        Returns a pair consisting of an index to the registered unary transit
4756        callback and a bool denoting whether the dimension has been created.
4757        It is false if a dimension with the same name has already been created
4758        (and doesn't create the new dimension but still register a new callback).
4759        """
4760        return _pywrapcp.RoutingModel_AddConstantDimensionWithSlack(self, value, capacity, slack_max, fix_start_cumul_to_zero, name)
4761
4762    def AddConstantDimension(self, value, capacity, fix_start_cumul_to_zero, name):
4763        return _pywrapcp.RoutingModel_AddConstantDimension(self, value, capacity, fix_start_cumul_to_zero, name)
4764
4765    def AddVectorDimension(self, values, capacity, fix_start_cumul_to_zero, name):
4766        r"""
4767        Creates a dimension where the transit variable is constrained to be
4768        equal to 'values[i]' for node i; 'capacity' is the upper bound of
4769        the cumul variables. 'name' is the name used to reference the dimension;
4770        this name is used to get cumul and transit variables from the routing
4771        model.
4772        Returns a pair consisting of an index to the registered unary transit
4773        callback and a bool denoting whether the dimension has been created.
4774        It is false if a dimension with the same name has already been created
4775        (and doesn't create the new dimension but still register a new callback).
4776        """
4777        return _pywrapcp.RoutingModel_AddVectorDimension(self, values, capacity, fix_start_cumul_to_zero, name)
4778
4779    def AddMatrixDimension(self, values, capacity, fix_start_cumul_to_zero, name):
4780        r"""
4781        Creates a dimension where the transit variable is constrained to be
4782        equal to 'values[i][next(i)]' for node i; 'capacity' is the upper bound of
4783        the cumul variables. 'name' is the name used to reference the dimension;
4784        this name is used to get cumul and transit variables from the routing
4785        model.
4786        Returns a pair consisting of an index to the registered transit callback
4787        and a bool denoting whether the dimension has been created.
4788        It is false if a dimension with the same name has already been created
4789        (and doesn't create the new dimension but still register a new callback).
4790        """
4791        return _pywrapcp.RoutingModel_AddMatrixDimension(self, values, capacity, fix_start_cumul_to_zero, name)
4792
4793    def GetAllDimensionNames(self):
4794        r""" Outputs the names of all dimensions added to the routing engine."""
4795        return _pywrapcp.RoutingModel_GetAllDimensionNames(self)
4796
4797    def GetDimensions(self):
4798        r""" Returns all dimensions of the model."""
4799        return _pywrapcp.RoutingModel_GetDimensions(self)
4800
4801    def GetDimensionsWithSoftOrSpanCosts(self):
4802        r""" Returns dimensions with soft or vehicle span costs."""
4803        return _pywrapcp.RoutingModel_GetDimensionsWithSoftOrSpanCosts(self)
4804
4805    def GetDimensionsWithGlobalCumulOptimizers(self):
4806        r""" Returns the dimensions which have [global|local]_dimension_optimizers_."""
4807        return _pywrapcp.RoutingModel_GetDimensionsWithGlobalCumulOptimizers(self)
4808
4809    def GetDimensionsWithLocalCumulOptimizers(self):
4810        return _pywrapcp.RoutingModel_GetDimensionsWithLocalCumulOptimizers(self)
4811
4812    def HasGlobalCumulOptimizer(self, dimension):
4813        r""" Returns whether the given dimension has global/local cumul optimizers."""
4814        return _pywrapcp.RoutingModel_HasGlobalCumulOptimizer(self, dimension)
4815
4816    def HasLocalCumulOptimizer(self, dimension):
4817        return _pywrapcp.RoutingModel_HasLocalCumulOptimizer(self, dimension)
4818
4819    def GetMutableGlobalCumulLPOptimizer(self, dimension):
4820        r"""
4821        Returns the global/local dimension cumul optimizer for a given dimension,
4822        or nullptr if there is none.
4823        """
4824        return _pywrapcp.RoutingModel_GetMutableGlobalCumulLPOptimizer(self, dimension)
4825
4826    def GetMutableGlobalCumulMPOptimizer(self, dimension):
4827        return _pywrapcp.RoutingModel_GetMutableGlobalCumulMPOptimizer(self, dimension)
4828
4829    def GetMutableLocalCumulLPOptimizer(self, dimension):
4830        return _pywrapcp.RoutingModel_GetMutableLocalCumulLPOptimizer(self, dimension)
4831
4832    def GetMutableLocalCumulMPOptimizer(self, dimension):
4833        return _pywrapcp.RoutingModel_GetMutableLocalCumulMPOptimizer(self, dimension)
4834
4835    def HasDimension(self, dimension_name):
4836        r""" Returns true if a dimension exists for a given dimension name."""
4837        return _pywrapcp.RoutingModel_HasDimension(self, dimension_name)
4838
4839    def GetDimensionOrDie(self, dimension_name):
4840        r""" Returns a dimension from its name. Dies if the dimension does not exist."""
4841        return _pywrapcp.RoutingModel_GetDimensionOrDie(self, dimension_name)
4842
4843    def GetMutableDimension(self, dimension_name):
4844        r"""
4845        Returns a dimension from its name. Returns nullptr if the dimension does
4846        not exist.
4847        """
4848        return _pywrapcp.RoutingModel_GetMutableDimension(self, dimension_name)
4849
4850    def SetPrimaryConstrainedDimension(self, dimension_name):
4851        r"""
4852        Set the given dimension as "primary constrained". As of August 2013, this
4853        is only used by ArcIsMoreConstrainedThanArc().
4854        "dimension" must be the name of an existing dimension, or be empty, in
4855        which case there will not be a primary dimension after this call.
4856        """
4857        return _pywrapcp.RoutingModel_SetPrimaryConstrainedDimension(self, dimension_name)
4858
4859    def GetPrimaryConstrainedDimension(self):
4860        r""" Get the primary constrained dimension, or an empty string if it is unset."""
4861        return _pywrapcp.RoutingModel_GetPrimaryConstrainedDimension(self)
4862
4863    def AddResourceGroup(self):
4864        r"""
4865        Adds a resource group to the routing model. Returns its index in
4866        resource_groups_.
4867        """
4868        return _pywrapcp.RoutingModel_AddResourceGroup(self)
4869
4870    def GetResourceGroups(self):
4871        return _pywrapcp.RoutingModel_GetResourceGroups(self)
4872
4873    def GetResourceGroup(self, rg_index):
4874        return _pywrapcp.RoutingModel_GetResourceGroup(self, rg_index)
4875
4876    def GetDimensionResourceGroupIndices(self, dimension):
4877        r"""
4878        Returns the indices of resource groups for this dimension. This method can
4879        only be called after the model has been closed.
4880        """
4881        return _pywrapcp.RoutingModel_GetDimensionResourceGroupIndices(self, dimension)
4882
4883    def GetDimensionResourceGroupIndex(self, dimension):
4884        r"""
4885        Returns the index of the resource group attached to the dimension.
4886        DCHECKS that there's exactly one resource group for this dimension.
4887        """
4888        return _pywrapcp.RoutingModel_GetDimensionResourceGroupIndex(self, dimension)
4889
4890    def AddDisjunction(self, *args):
4891        r"""
4892        Adds a disjunction constraint on the indices: exactly 'max_cardinality' of
4893        the indices are active. Start and end indices of any vehicle cannot be
4894        part of a disjunction.
4895
4896        If a penalty is given, at most 'max_cardinality' of the indices can be
4897        active, and if less are active, 'penalty' is payed per inactive index.
4898        This is equivalent to adding the constraint:
4899            p + Sum(i)active[i] == max_cardinality
4900        where p is an integer variable, and the following cost to the cost
4901        function:
4902            p * penalty.
4903        'penalty' must be positive to make the disjunction optional; a negative
4904        penalty will force 'max_cardinality' indices of the disjunction to be
4905        performed, and therefore p == 0.
4906        Note: passing a vector with a single index will model an optional index
4907        with a penalty cost if it is not visited.
4908        """
4909        return _pywrapcp.RoutingModel_AddDisjunction(self, *args)
4910
4911    def GetDisjunctionIndices(self, index):
4912        r""" Returns the indices of the disjunctions to which an index belongs."""
4913        return _pywrapcp.RoutingModel_GetDisjunctionIndices(self, index)
4914
4915    def GetDisjunctionPenalty(self, index):
4916        r""" Returns the penalty of the node disjunction of index 'index'."""
4917        return _pywrapcp.RoutingModel_GetDisjunctionPenalty(self, index)
4918
4919    def GetDisjunctionMaxCardinality(self, index):
4920        r"""
4921        Returns the maximum number of possible active nodes of the node
4922        disjunction of index 'index'.
4923        """
4924        return _pywrapcp.RoutingModel_GetDisjunctionMaxCardinality(self, index)
4925
4926    def GetNumberOfDisjunctions(self):
4927        r""" Returns the number of node disjunctions in the model."""
4928        return _pywrapcp.RoutingModel_GetNumberOfDisjunctions(self)
4929
4930    def HasMandatoryDisjunctions(self):
4931        r"""
4932        Returns true if the model contains mandatory disjunctions (ones with
4933        kNoPenalty as penalty).
4934        """
4935        return _pywrapcp.RoutingModel_HasMandatoryDisjunctions(self)
4936
4937    def HasMaxCardinalityConstrainedDisjunctions(self):
4938        r"""
4939        Returns true if the model contains at least one disjunction which is
4940        constrained by its max_cardinality.
4941        """
4942        return _pywrapcp.RoutingModel_HasMaxCardinalityConstrainedDisjunctions(self)
4943
4944    def GetPerfectBinaryDisjunctions(self):
4945        r"""
4946        Returns the list of all perfect binary disjunctions, as pairs of variable
4947        indices: a disjunction is "perfect" when its variables do not appear in
4948        any other disjunction. Each pair is sorted (lowest variable index first),
4949        and the output vector is also sorted (lowest pairs first).
4950        """
4951        return _pywrapcp.RoutingModel_GetPerfectBinaryDisjunctions(self)
4952
4953    def IgnoreDisjunctionsAlreadyForcedToZero(self):
4954        r"""
4955        SPECIAL: Makes the solver ignore all the disjunctions whose active
4956        variables are all trivially zero (i.e. Max() == 0), by setting their
4957        max_cardinality to 0.
4958        This can be useful when using the BaseBinaryDisjunctionNeighborhood
4959        operators, in the context of arc-based routing.
4960        """
4961        return _pywrapcp.RoutingModel_IgnoreDisjunctionsAlreadyForcedToZero(self)
4962
4963    def AddSoftSameVehicleConstraint(self, indices, cost):
4964        r"""
4965        Adds a soft constraint to force a set of variable indices to be on the
4966        same vehicle. If all nodes are not on the same vehicle, each extra vehicle
4967        used adds 'cost' to the cost function.
4968        """
4969        return _pywrapcp.RoutingModel_AddSoftSameVehicleConstraint(self, indices, cost)
4970
4971    def SetAllowedVehiclesForIndex(self, vehicles, index):
4972        r"""
4973        Sets the vehicles which can visit a given node. If the node is in a
4974        disjunction, this will not prevent it from being unperformed.
4975        Specifying an empty vector of vehicles has no effect (all vehicles
4976        will be allowed to visit the node).
4977        """
4978        return _pywrapcp.RoutingModel_SetAllowedVehiclesForIndex(self, vehicles, index)
4979
4980    def IsVehicleAllowedForIndex(self, vehicle, index):
4981        r""" Returns true if a vehicle is allowed to visit a given node."""
4982        return _pywrapcp.RoutingModel_IsVehicleAllowedForIndex(self, vehicle, index)
4983
4984    def AddPickupAndDelivery(self, pickup, delivery):
4985        r"""
4986        Notifies that index1 and index2 form a pair of nodes which should belong
4987        to the same route. This methods helps the search find better solutions,
4988        especially in the local search phase.
4989        It should be called each time you have an equality constraint linking
4990        the vehicle variables of two node (including for instance pickup and
4991        delivery problems):
4992            Solver* const solver = routing.solver();
4993            int64_t index1 = manager.NodeToIndex(node1);
4994            int64_t index2 = manager.NodeToIndex(node2);
4995            solver->AddConstraint(solver->MakeEquality(
4996                routing.VehicleVar(index1),
4997                routing.VehicleVar(index2)));
4998            routing.AddPickupAndDelivery(index1, index2);
4999        """
5000        return _pywrapcp.RoutingModel_AddPickupAndDelivery(self, pickup, delivery)
5001
5002    def AddPickupAndDeliverySets(self, pickup_disjunction, delivery_disjunction):
5003        r"""
5004        Same as AddPickupAndDelivery but notifying that the performed node from
5005        the disjunction of index 'pickup_disjunction' is on the same route as the
5006        performed node from the disjunction of index 'delivery_disjunction'.
5007        """
5008        return _pywrapcp.RoutingModel_AddPickupAndDeliverySets(self, pickup_disjunction, delivery_disjunction)
5009
5010    def GetPickupIndexPairs(self, node_index):
5011        r"""
5012        Returns pairs for which the node is a pickup; the first element of each
5013        pair is the index in the pickup and delivery pairs list in which the
5014        pickup appears, the second element is its index in the pickups list.
5015        """
5016        return _pywrapcp.RoutingModel_GetPickupIndexPairs(self, node_index)
5017
5018    def GetDeliveryIndexPairs(self, node_index):
5019        r""" Same as above for deliveries."""
5020        return _pywrapcp.RoutingModel_GetDeliveryIndexPairs(self, node_index)
5021
5022    def SetPickupAndDeliveryPolicyOfAllVehicles(self, policy):
5023        r"""
5024        Sets the Pickup and delivery policy of all vehicles. It is equivalent to
5025        calling SetPickupAndDeliveryPolicyOfVehicle on all vehicles.
5026        """
5027        return _pywrapcp.RoutingModel_SetPickupAndDeliveryPolicyOfAllVehicles(self, policy)
5028
5029    def SetPickupAndDeliveryPolicyOfVehicle(self, policy, vehicle):
5030        return _pywrapcp.RoutingModel_SetPickupAndDeliveryPolicyOfVehicle(self, policy, vehicle)
5031
5032    def GetPickupAndDeliveryPolicyOfVehicle(self, vehicle):
5033        return _pywrapcp.RoutingModel_GetPickupAndDeliveryPolicyOfVehicle(self, vehicle)
5034
5035    def GetNumOfSingletonNodes(self):
5036        r"""
5037        Returns the number of non-start/end nodes which do not appear in a
5038        pickup/delivery pair.
5039        """
5040        return _pywrapcp.RoutingModel_GetNumOfSingletonNodes(self)
5041    TYPE_ADDED_TO_VEHICLE = _pywrapcp.RoutingModel_TYPE_ADDED_TO_VEHICLE
5042    r""" When visited, the number of types 'T' on the vehicle increases by one."""
5043    ADDED_TYPE_REMOVED_FROM_VEHICLE = _pywrapcp.RoutingModel_ADDED_TYPE_REMOVED_FROM_VEHICLE
5044    r"""
5045    When visited, one instance of type 'T' previously added to the route
5046    (TYPE_ADDED_TO_VEHICLE), if any, is removed from the vehicle.
5047    If the type was not previously added to the route or all added instances
5048    have already been removed, this visit has no effect on the types.
5049    """
5050    TYPE_ON_VEHICLE_UP_TO_VISIT = _pywrapcp.RoutingModel_TYPE_ON_VEHICLE_UP_TO_VISIT
5051    r"""
5052    With the following policy, the visit enforces that type 'T' is
5053    considered on the route from its start until this node is visited.
5054    """
5055    TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED = _pywrapcp.RoutingModel_TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED
5056    r"""
5057    The visit doesn't have an impact on the number of types 'T' on the
5058    route, as it's (virtually) added and removed directly.
5059    This policy can be used for visits which are part of an incompatibility
5060    or requirement set without affecting the type count on the route.
5061    """
5062
5063    def SetVisitType(self, index, type, type_policy):
5064        return _pywrapcp.RoutingModel_SetVisitType(self, index, type, type_policy)
5065
5066    def GetVisitType(self, index):
5067        return _pywrapcp.RoutingModel_GetVisitType(self, index)
5068
5069    def GetSingleNodesOfType(self, type):
5070        return _pywrapcp.RoutingModel_GetSingleNodesOfType(self, type)
5071
5072    def GetPairIndicesOfType(self, type):
5073        return _pywrapcp.RoutingModel_GetPairIndicesOfType(self, type)
5074
5075    def GetVisitTypePolicy(self, index):
5076        return _pywrapcp.RoutingModel_GetVisitTypePolicy(self, index)
5077
5078    def CloseVisitTypes(self):
5079        r"""
5080        This function should be called once all node visit types have been set and
5081        prior to adding any incompatibilities/requirements.
5082        "close" types.
5083        """
5084        return _pywrapcp.RoutingModel_CloseVisitTypes(self)
5085
5086    def GetNumberOfVisitTypes(self):
5087        return _pywrapcp.RoutingModel_GetNumberOfVisitTypes(self)
5088
5089    def AddHardTypeIncompatibility(self, type1, type2):
5090        r"""
5091        Incompatibilities:
5092        Two nodes with "hard" incompatible types cannot share the same route at
5093        all, while with a "temporal" incompatibility they can't be on the same
5094        route at the same time.
5095        """
5096        return _pywrapcp.RoutingModel_AddHardTypeIncompatibility(self, type1, type2)
5097
5098    def AddTemporalTypeIncompatibility(self, type1, type2):
5099        return _pywrapcp.RoutingModel_AddTemporalTypeIncompatibility(self, type1, type2)
5100
5101    def GetHardTypeIncompatibilitiesOfType(self, type):
5102        r""" Returns visit types incompatible with a given type."""
5103        return _pywrapcp.RoutingModel_GetHardTypeIncompatibilitiesOfType(self, type)
5104
5105    def GetTemporalTypeIncompatibilitiesOfType(self, type):
5106        return _pywrapcp.RoutingModel_GetTemporalTypeIncompatibilitiesOfType(self, type)
5107
5108    def HasHardTypeIncompatibilities(self):
5109        r"""
5110        Returns true iff any hard (resp. temporal) type incompatibilities have
5111        been added to the model.
5112        """
5113        return _pywrapcp.RoutingModel_HasHardTypeIncompatibilities(self)
5114
5115    def HasTemporalTypeIncompatibilities(self):
5116        return _pywrapcp.RoutingModel_HasTemporalTypeIncompatibilities(self)
5117
5118    def AddSameVehicleRequiredTypeAlternatives(self, dependent_type, required_type_alternatives):
5119        r"""
5120        Requirements:
5121        NOTE: As of 2019-04, cycles in the requirement graph are not supported,
5122        and lead to the dependent nodes being skipped if possible (otherwise
5123        the model is considered infeasible).
5124        The following functions specify that "dependent_type" requires at least
5125        one of the types in "required_type_alternatives".
5126
5127        For same-vehicle requirements, a node of dependent type type_D requires at
5128        least one node of type type_R among the required alternatives on the same
5129        route.
5130        """
5131        return _pywrapcp.RoutingModel_AddSameVehicleRequiredTypeAlternatives(self, dependent_type, required_type_alternatives)
5132
5133    def AddRequiredTypeAlternativesWhenAddingType(self, dependent_type, required_type_alternatives):
5134        r"""
5135        If type_D depends on type_R when adding type_D, any node_D of type_D and
5136        VisitTypePolicy TYPE_ADDED_TO_VEHICLE or
5137        TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED requires at least one type_R on its
5138        vehicle at the time node_D is visited.
5139        """
5140        return _pywrapcp.RoutingModel_AddRequiredTypeAlternativesWhenAddingType(self, dependent_type, required_type_alternatives)
5141
5142    def AddRequiredTypeAlternativesWhenRemovingType(self, dependent_type, required_type_alternatives):
5143        r"""
5144        The following requirements apply when visiting dependent nodes that remove
5145        their type from the route, i.e. type_R must be on the vehicle when type_D
5146        of VisitTypePolicy ADDED_TYPE_REMOVED_FROM_VEHICLE,
5147        TYPE_ON_VEHICLE_UP_TO_VISIT or TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED is
5148        visited.
5149        """
5150        return _pywrapcp.RoutingModel_AddRequiredTypeAlternativesWhenRemovingType(self, dependent_type, required_type_alternatives)
5151
5152    def GetSameVehicleRequiredTypeAlternativesOfType(self, type):
5153        r"""
5154        Returns the set of same-vehicle requirement alternatives for the given
5155        type.
5156        """
5157        return _pywrapcp.RoutingModel_GetSameVehicleRequiredTypeAlternativesOfType(self, type)
5158
5159    def GetRequiredTypeAlternativesWhenAddingType(self, type):
5160        r""" Returns the set of requirement alternatives when adding the given type."""
5161        return _pywrapcp.RoutingModel_GetRequiredTypeAlternativesWhenAddingType(self, type)
5162
5163    def GetRequiredTypeAlternativesWhenRemovingType(self, type):
5164        r""" Returns the set of requirement alternatives when removing the given type."""
5165        return _pywrapcp.RoutingModel_GetRequiredTypeAlternativesWhenRemovingType(self, type)
5166
5167    def HasSameVehicleTypeRequirements(self):
5168        r"""
5169        Returns true iff any same-route (resp. temporal) type requirements have
5170        been added to the model.
5171        """
5172        return _pywrapcp.RoutingModel_HasSameVehicleTypeRequirements(self)
5173
5174    def HasTemporalTypeRequirements(self):
5175        return _pywrapcp.RoutingModel_HasTemporalTypeRequirements(self)
5176
5177    def HasTypeRegulations(self):
5178        r"""
5179        Returns true iff the model has any incompatibilities or requirements set
5180        on node types.
5181        """
5182        return _pywrapcp.RoutingModel_HasTypeRegulations(self)
5183
5184    def UnperformedPenalty(self, var_index):
5185        r"""
5186        Get the "unperformed" penalty of a node. This is only well defined if the
5187        node is only part of a single Disjunction, and that disjunction has a
5188        penalty. For forced active nodes returns max int64_t. In all other cases,
5189        this returns 0.
5190        """
5191        return _pywrapcp.RoutingModel_UnperformedPenalty(self, var_index)
5192
5193    def UnperformedPenaltyOrValue(self, default_value, var_index):
5194        r"""
5195        Same as above except that it returns default_value instead of 0 when
5196        penalty is not well defined (default value is passed as first argument to
5197        simplify the usage of the method in a callback).
5198        """
5199        return _pywrapcp.RoutingModel_UnperformedPenaltyOrValue(self, default_value, var_index)
5200
5201    def GetDepot(self):
5202        r"""
5203        Returns the variable index of the first starting or ending node of all
5204        routes. If all routes start  and end at the same node (single depot), this
5205        is the node returned.
5206        """
5207        return _pywrapcp.RoutingModel_GetDepot(self)
5208
5209    def SetMaximumNumberOfActiveVehicles(self, max_active_vehicles):
5210        r"""
5211        Constrains the maximum number of active vehicles, aka the number of
5212        vehicles which do not have an empty route. For instance, this can be used
5213        to limit the number of routes in the case where there are fewer drivers
5214        than vehicles and that the fleet of vehicle is heterogeneous.
5215        """
5216        return _pywrapcp.RoutingModel_SetMaximumNumberOfActiveVehicles(self, max_active_vehicles)
5217
5218    def GetMaximumNumberOfActiveVehicles(self):
5219        r""" Returns the maximum number of active vehicles."""
5220        return _pywrapcp.RoutingModel_GetMaximumNumberOfActiveVehicles(self)
5221
5222    def SetArcCostEvaluatorOfAllVehicles(self, evaluator_index):
5223        r"""
5224        Sets the cost function of the model such that the cost of a segment of a
5225        route between node 'from' and 'to' is evaluator(from, to), whatever the
5226        route or vehicle performing the route.
5227        """
5228        return _pywrapcp.RoutingModel_SetArcCostEvaluatorOfAllVehicles(self, evaluator_index)
5229
5230    def SetArcCostEvaluatorOfVehicle(self, evaluator_index, vehicle):
5231        r""" Sets the cost function for a given vehicle route."""
5232        return _pywrapcp.RoutingModel_SetArcCostEvaluatorOfVehicle(self, evaluator_index, vehicle)
5233
5234    def SetFixedCostOfAllVehicles(self, cost):
5235        r"""
5236        Sets the fixed cost of all vehicle routes. It is equivalent to calling
5237        SetFixedCostOfVehicle on all vehicle routes.
5238        """
5239        return _pywrapcp.RoutingModel_SetFixedCostOfAllVehicles(self, cost)
5240
5241    def SetFixedCostOfVehicle(self, cost, vehicle):
5242        r""" Sets the fixed cost of one vehicle route."""
5243        return _pywrapcp.RoutingModel_SetFixedCostOfVehicle(self, cost, vehicle)
5244
5245    def GetFixedCostOfVehicle(self, vehicle):
5246        r"""
5247        Returns the route fixed cost taken into account if the route of the
5248        vehicle is not empty, aka there's at least one node on the route other
5249        than the first and last nodes.
5250        """
5251        return _pywrapcp.RoutingModel_GetFixedCostOfVehicle(self, vehicle)
5252
5253    def SetPathEnergyCostOfVehicle(self, force, distance, unit_cost, vehicle):
5254        return _pywrapcp.RoutingModel_SetPathEnergyCostOfVehicle(self, force, distance, unit_cost, vehicle)
5255
5256    def SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor, quadratic_cost_factor):
5257        r"""
5258        The following methods set the linear and quadratic cost factors of
5259        vehicles (must be positive values). The default value of these parameters
5260        is zero for all vehicles.
5261
5262        When set, the cost_ of the model will contain terms aiming at reducing the
5263        number of vehicles used in the model, by adding the following to the
5264        objective for every vehicle v:
5265        INDICATOR(v used in the model) *
5266          [linear_cost_factor_of_vehicle_[v]
5267           - quadratic_cost_factor_of_vehicle_[v]*(square of length of route v)]
5268        i.e. for every used vehicle, we add the linear factor as fixed cost, and
5269        subtract the square of the route length multiplied by the quadratic
5270        factor. This second term aims at making the routes as dense as possible.
5271
5272        Sets the linear and quadratic cost factor of all vehicles.
5273        """
5274        return _pywrapcp.RoutingModel_SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor, quadratic_cost_factor)
5275
5276    def SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor, quadratic_cost_factor, vehicle):
5277        r""" Sets the linear and quadratic cost factor of the given vehicle."""
5278        return _pywrapcp.RoutingModel_SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor, quadratic_cost_factor, vehicle)
5279
5280    def GetAmortizedLinearCostFactorOfVehicles(self):
5281        return _pywrapcp.RoutingModel_GetAmortizedLinearCostFactorOfVehicles(self)
5282
5283    def GetAmortizedQuadraticCostFactorOfVehicles(self):
5284        return _pywrapcp.RoutingModel_GetAmortizedQuadraticCostFactorOfVehicles(self)
5285
5286    def SetVehicleUsedWhenEmpty(self, is_used, vehicle):
5287        return _pywrapcp.RoutingModel_SetVehicleUsedWhenEmpty(self, is_used, vehicle)
5288
5289    def IsVehicleUsedWhenEmpty(self, vehicle):
5290        return _pywrapcp.RoutingModel_IsVehicleUsedWhenEmpty(self, vehicle)
5291
5292    def SetFirstSolutionEvaluator(self, evaluator):
5293        r"""
5294        Gets/sets the evaluator used during the search. Only relevant when
5295        RoutingSearchParameters.first_solution_strategy = EVALUATOR_STRATEGY.
5296        Takes ownership of evaluator.
5297        """
5298        return _pywrapcp.RoutingModel_SetFirstSolutionEvaluator(self, evaluator)
5299
5300    def AddLocalSearchOperator(self, ls_operator):
5301        r"""
5302        Adds a local search operator to the set of operators used to solve the
5303        vehicle routing problem.
5304        """
5305        return _pywrapcp.RoutingModel_AddLocalSearchOperator(self, ls_operator)
5306
5307    def AddSearchMonitor(self, monitor):
5308        r""" Adds a search monitor to the search used to solve the routing model."""
5309        return _pywrapcp.RoutingModel_AddSearchMonitor(self, monitor)
5310
5311    def AddAtSolutionCallback(self, callback, track_unchecked_neighbors=False):
5312        r"""
5313        Adds a callback called each time a solution is found during the search.
5314        This is a shortcut to creating a monitor to call the callback on
5315        AtSolution() and adding it with AddSearchMonitor.
5316        If track_unchecked_neighbors is true, the callback will also be called on
5317        AcceptUncheckedNeighbor() events, which is useful to grab solutions
5318        obtained when solver_parameters.check_solution_period > 1 (aka fastLS).
5319        """
5320        return _pywrapcp.RoutingModel_AddAtSolutionCallback(self, callback, track_unchecked_neighbors)
5321
5322    def AddVariableMinimizedByFinalizer(self, var):
5323        r"""
5324        Adds a variable to minimize in the solution finalizer. The solution
5325        finalizer is called each time a solution is found during the search and
5326        allows to instantiate secondary variables (such as dimension cumul
5327        variables).
5328        """
5329        return _pywrapcp.RoutingModel_AddVariableMinimizedByFinalizer(self, var)
5330
5331    def AddVariableMaximizedByFinalizer(self, var):
5332        r"""
5333        Adds a variable to maximize in the solution finalizer (see above for
5334        information on the solution finalizer).
5335        """
5336        return _pywrapcp.RoutingModel_AddVariableMaximizedByFinalizer(self, var)
5337
5338    def AddWeightedVariableMinimizedByFinalizer(self, var, cost):
5339        r"""
5340        Adds a variable to minimize in the solution finalizer, with a weighted
5341        priority: the higher the more priority it has.
5342        """
5343        return _pywrapcp.RoutingModel_AddWeightedVariableMinimizedByFinalizer(self, var, cost)
5344
5345    def AddWeightedVariableMaximizedByFinalizer(self, var, cost):
5346        r"""
5347        Adds a variable to maximize in the solution finalizer, with a weighted
5348        priority: the higher the more priority it has.
5349        """
5350        return _pywrapcp.RoutingModel_AddWeightedVariableMaximizedByFinalizer(self, var, cost)
5351
5352    def AddVariableTargetToFinalizer(self, var, target):
5353        r"""
5354        Add a variable to set the closest possible to the target value in the
5355        solution finalizer.
5356        """
5357        return _pywrapcp.RoutingModel_AddVariableTargetToFinalizer(self, var, target)
5358
5359    def AddWeightedVariableTargetToFinalizer(self, var, target, cost):
5360        r"""
5361        Same as above with a weighted priority: the higher the cost, the more
5362        priority it has to be set close to the target value.
5363        """
5364        return _pywrapcp.RoutingModel_AddWeightedVariableTargetToFinalizer(self, var, target, cost)
5365
5366    def CloseModel(self):
5367        r"""
5368        Closes the current routing model; after this method is called, no
5369        modification to the model can be done, but RoutesToAssignment becomes
5370        available. Note that CloseModel() is automatically called by Solve() and
5371        other methods that produce solution.
5372        This is equivalent to calling
5373        CloseModelWithParameters(DefaultRoutingSearchParameters()).
5374        """
5375        return _pywrapcp.RoutingModel_CloseModel(self)
5376
5377    def CloseModelWithParameters(self, search_parameters):
5378        r"""
5379        Same as above taking search parameters (as of 10/2015 some the parameters
5380        have to be set when closing the model).
5381        """
5382        return _pywrapcp.RoutingModel_CloseModelWithParameters(self, search_parameters)
5383
5384    def Solve(self, assignment=None):
5385        r"""
5386        Solves the current routing model; closes the current model.
5387        This is equivalent to calling
5388        SolveWithParameters(DefaultRoutingSearchParameters())
5389        or
5390        SolveFromAssignmentWithParameters(assignment,
5391                                          DefaultRoutingSearchParameters()).
5392        """
5393        return _pywrapcp.RoutingModel_Solve(self, assignment)
5394
5395    def SolveWithParameters(self, search_parameters, solutions=None):
5396        r"""
5397        Solves the current routing model with the given parameters. If 'solutions'
5398        is specified, it will contain the k best solutions found during the search
5399        (from worst to best, including the one returned by this method), where k
5400        corresponds to the 'number_of_solutions_to_collect' in
5401        'search_parameters'. Note that the Assignment returned by the method and
5402        the ones in solutions are owned by the underlying solver and should not be
5403        deleted.
5404        """
5405        return _pywrapcp.RoutingModel_SolveWithParameters(self, search_parameters, solutions)
5406
5407    def SolveFromAssignmentWithParameters(self, assignment, search_parameters, solutions=None):
5408        r"""
5409        Same as above, except that if assignment is not null, it will be used as
5410        the initial solution.
5411        """
5412        return _pywrapcp.RoutingModel_SolveFromAssignmentWithParameters(self, assignment, search_parameters, solutions)
5413
5414    def SolveFromAssignmentsWithParameters(self, assignments, search_parameters, solutions=None):
5415        r"""
5416        Same as above but will try all assignments in order as first solutions
5417        until one succeeds.
5418        """
5419        return _pywrapcp.RoutingModel_SolveFromAssignmentsWithParameters(self, assignments, search_parameters, solutions)
5420
5421    def SetAssignmentFromOtherModelAssignment(self, target_assignment, source_model, source_assignment):
5422        r"""
5423        Given a "source_model" and its "source_assignment", resets
5424        "target_assignment" with the IntVar variables (nexts_, and vehicle_vars_
5425        if costs aren't homogeneous across vehicles) of "this" model, with the
5426        values set according to those in "other_assignment".
5427        The objective_element of target_assignment is set to this->cost_.
5428        """
5429        return _pywrapcp.RoutingModel_SetAssignmentFromOtherModelAssignment(self, target_assignment, source_model, source_assignment)
5430
5431    def ComputeLowerBound(self):
5432        r"""
5433        Computes a lower bound to the routing problem solving a linear assignment
5434        problem. The routing model must be closed before calling this method.
5435        Note that problems with node disjunction constraints (including optional
5436        nodes) and non-homogenous costs are not supported (the method returns 0 in
5437        these cases).
5438        """
5439        return _pywrapcp.RoutingModel_ComputeLowerBound(self)
5440
5441    def status(self):
5442        r""" Returns the current status of the routing model."""
5443        return _pywrapcp.RoutingModel_status(self)
5444
5445    def enable_deep_serialization(self):
5446        r""" Returns the value of the internal enable_deep_serialization_ parameter."""
5447        return _pywrapcp.RoutingModel_enable_deep_serialization(self)
5448
5449    def ApplyLocks(self, locks):
5450        r"""
5451        Applies a lock chain to the next search. 'locks' represents an ordered
5452        vector of nodes representing a partial route which will be fixed during
5453        the next search; it will constrain next variables such that:
5454        next[locks[i]] == locks[i+1].
5455
5456        Returns the next variable at the end of the locked chain; this variable is
5457        not locked. An assignment containing the locks can be obtained by calling
5458        PreAssignment().
5459        """
5460        return _pywrapcp.RoutingModel_ApplyLocks(self, locks)
5461
5462    def ApplyLocksToAllVehicles(self, locks, close_routes):
5463        r"""
5464        Applies lock chains to all vehicles to the next search, such that locks[p]
5465        is the lock chain for route p. Returns false if the locks do not contain
5466        valid routes; expects that the routes do not contain the depots,
5467        i.e. there are empty vectors in place of empty routes.
5468        If close_routes is set to true, adds the end nodes to the route of each
5469        vehicle and deactivates other nodes.
5470        An assignment containing the locks can be obtained by calling
5471        PreAssignment().
5472        """
5473        return _pywrapcp.RoutingModel_ApplyLocksToAllVehicles(self, locks, close_routes)
5474
5475    def PreAssignment(self):
5476        r"""
5477        Returns an assignment used to fix some of the variables of the problem.
5478        In practice, this assignment locks partial routes of the problem. This
5479        can be used in the context of locking the parts of the routes which have
5480        already been driven in online routing problems.
5481        """
5482        return _pywrapcp.RoutingModel_PreAssignment(self)
5483
5484    def MutablePreAssignment(self):
5485        return _pywrapcp.RoutingModel_MutablePreAssignment(self)
5486
5487    def WriteAssignment(self, file_name):
5488        r"""
5489        Writes the current solution to a file containing an AssignmentProto.
5490        Returns false if the file cannot be opened or if there is no current
5491        solution.
5492        """
5493        return _pywrapcp.RoutingModel_WriteAssignment(self, file_name)
5494
5495    def ReadAssignment(self, file_name):
5496        r"""
5497        Reads an assignment from a file and returns the current solution.
5498        Returns nullptr if the file cannot be opened or if the assignment is not
5499        valid.
5500        """
5501        return _pywrapcp.RoutingModel_ReadAssignment(self, file_name)
5502
5503    def RestoreAssignment(self, solution):
5504        r"""
5505        Restores an assignment as a solution in the routing model and returns the
5506        new solution. Returns nullptr if the assignment is not valid.
5507        """
5508        return _pywrapcp.RoutingModel_RestoreAssignment(self, solution)
5509
5510    def ReadAssignmentFromRoutes(self, routes, ignore_inactive_indices):
5511        r"""
5512        Restores the routes as the current solution. Returns nullptr if the
5513        solution cannot be restored (routes do not contain a valid solution). Note
5514        that calling this method will run the solver to assign values to the
5515        dimension variables; this may take considerable amount of time, especially
5516        when using dimensions with slack.
5517        """
5518        return _pywrapcp.RoutingModel_ReadAssignmentFromRoutes(self, routes, ignore_inactive_indices)
5519
5520    def RoutesToAssignment(self, routes, ignore_inactive_indices, close_routes, assignment):
5521        r"""
5522        Fills an assignment from a specification of the routes of the
5523        vehicles. The routes are specified as lists of variable indices that
5524        appear on the routes of the vehicles. The indices of the outer vector in
5525        'routes' correspond to vehicles IDs, the inner vector contains the
5526        variable indices on the routes for the given vehicle. The inner vectors
5527        must not contain the start and end indices, as these are determined by the
5528        routing model.  Sets the value of NextVars in the assignment, adding the
5529        variables to the assignment if necessary. The method does not touch other
5530        variables in the assignment. The method can only be called after the model
5531        is closed.  With ignore_inactive_indices set to false, this method will
5532        fail (return nullptr) in case some of the route contain indices that are
5533        deactivated in the model; when set to true, these indices will be
5534        skipped.  Returns true if routes were successfully
5535        loaded. However, such assignment still might not be a valid
5536        solution to the routing problem due to more complex constraints;
5537        it is advisible to call solver()->CheckSolution() afterwards.
5538        """
5539        return _pywrapcp.RoutingModel_RoutesToAssignment(self, routes, ignore_inactive_indices, close_routes, assignment)
5540
5541    def AssignmentToRoutes(self, assignment, routes):
5542        r"""
5543        Converts the solution in the given assignment to routes for all vehicles.
5544        Expects that assignment contains a valid solution (i.e. routes for all
5545        vehicles end with an end index for that vehicle).
5546        """
5547        return _pywrapcp.RoutingModel_AssignmentToRoutes(self, assignment, routes)
5548
5549    def CompactAssignment(self, assignment):
5550        r"""
5551        Converts the solution in the given assignment to routes for all vehicles.
5552        If the returned vector is route_indices, route_indices[i][j] is the index
5553        for jth location visited on route i. Note that contrary to
5554        AssignmentToRoutes, the vectors do include start and end locations.
5555        Returns a compacted version of the given assignment, in which all vehicles
5556        with id lower or equal to some N have non-empty routes, and all vehicles
5557        with id greater than N have empty routes. Does not take ownership of the
5558        returned object.
5559        If found, the cost of the compact assignment is the same as in the
5560        original assignment and it preserves the values of 'active' variables.
5561        Returns nullptr if a compact assignment was not found.
5562        This method only works in homogenous mode, and it only swaps equivalent
5563        vehicles (vehicles with the same start and end nodes). When creating the
5564        compact assignment, the empty plan is replaced by the route assigned to
5565        the compatible vehicle with the highest id. Note that with more complex
5566        constraints on vehicle variables, this method might fail even if a compact
5567        solution exists.
5568        This method changes the vehicle and dimension variables as necessary.
5569        While compacting the solution, only basic checks on vehicle variables are
5570        performed; if one of these checks fails no attempts to repair it are made
5571        (instead, the method returns nullptr).
5572        """
5573        return _pywrapcp.RoutingModel_CompactAssignment(self, assignment)
5574
5575    def CompactAndCheckAssignment(self, assignment):
5576        r"""
5577        Same as CompactAssignment() but also checks the validity of the final
5578        compact solution; if it is not valid, no attempts to repair it are made
5579        (instead, the method returns nullptr).
5580        """
5581        return _pywrapcp.RoutingModel_CompactAndCheckAssignment(self, assignment)
5582
5583    def AddToAssignment(self, var):
5584        r""" Adds an extra variable to the vehicle routing assignment."""
5585        return _pywrapcp.RoutingModel_AddToAssignment(self, var)
5586
5587    def AddIntervalToAssignment(self, interval):
5588        return _pywrapcp.RoutingModel_AddIntervalToAssignment(self, interval)
5589
5590    def PackCumulsOfOptimizerDimensionsFromAssignment(self, original_assignment, duration_limit, time_limit_was_reached=None):
5591        r"""
5592        For every dimension in the model with an optimizer in
5593        local/global_dimension_optimizers_, this method tries to pack the cumul
5594        values of the dimension, such that:
5595        - The cumul costs (span costs, soft lower and upper bound costs, etc) are
5596          minimized.
5597        - The cumuls of the ends of the routes are minimized for this given
5598          minimal cumul cost.
5599        - Given these minimal end cumuls, the route start cumuls are maximized.
5600        Returns the assignment resulting from allocating these packed cumuls with
5601        the solver, and nullptr if these cumuls could not be set by the solver.
5602        """
5603        return _pywrapcp.RoutingModel_PackCumulsOfOptimizerDimensionsFromAssignment(self, original_assignment, duration_limit, time_limit_was_reached)
5604
5605    def GetOrCreateNodeNeighborsByCostClass(self, *args):
5606        r"""
5607        *Overload 1:*
5608        Returns neighbors of all nodes for every cost class. The result is cached
5609        and is computed once. The number of neighbors considered is based on a
5610        ratio of non-vehicle nodes, specified by neighbors_ratio, with a minimum
5611        of min-neighbors node considered.
5612
5613        |
5614
5615        *Overload 2:*
5616        Returns parameters.num_neighbors neighbors of all nodes for every cost
5617        class. The result is cached and is computed once.
5618
5619        |
5620
5621        *Overload 3:*
5622        Returns parameters.num_neighbors neighbors of all nodes for every cost
5623        class. The result is cached and is computed once.
5624        """
5625        return _pywrapcp.RoutingModel_GetOrCreateNodeNeighborsByCostClass(self, *args)
5626
5627    def AddLocalSearchFilter(self, filter):
5628        r"""
5629        Adds a custom local search filter to the list of filters used to speed up
5630        local search by pruning unfeasible variable assignments.
5631        Calling this method after the routing model has been closed (CloseModel()
5632        or Solve() has been called) has no effect.
5633        The routing model does not take ownership of the filter.
5634        """
5635        return _pywrapcp.RoutingModel_AddLocalSearchFilter(self, filter)
5636
5637    def Start(self, vehicle):
5638        r"""
5639        Model inspection.
5640        Returns the variable index of the starting node of a vehicle route.
5641        """
5642        return _pywrapcp.RoutingModel_Start(self, vehicle)
5643
5644    def End(self, vehicle):
5645        r""" Returns the variable index of the ending node of a vehicle route."""
5646        return _pywrapcp.RoutingModel_End(self, vehicle)
5647
5648    def IsStart(self, index):
5649        r""" Returns true if 'index' represents the first node of a route."""
5650        return _pywrapcp.RoutingModel_IsStart(self, index)
5651
5652    def IsEnd(self, index):
5653        r""" Returns true if 'index' represents the last node of a route."""
5654        return _pywrapcp.RoutingModel_IsEnd(self, index)
5655
5656    def VehicleIndex(self, index):
5657        r"""
5658        Returns the vehicle of the given start/end index, and -1 if the given
5659        index is not a vehicle start/end.
5660        """
5661        return _pywrapcp.RoutingModel_VehicleIndex(self, index)
5662
5663    def Next(self, assignment, index):
5664        r"""
5665        Assignment inspection
5666        Returns the variable index of the node directly after the node
5667        corresponding to 'index' in 'assignment'.
5668        """
5669        return _pywrapcp.RoutingModel_Next(self, assignment, index)
5670
5671    def IsVehicleUsed(self, assignment, vehicle):
5672        r""" Returns true if the route of 'vehicle' is non empty in 'assignment'."""
5673        return _pywrapcp.RoutingModel_IsVehicleUsed(self, assignment, vehicle)
5674
5675    def NextVar(self, index):
5676        r"""
5677        Returns the next variable of the node corresponding to index. Note that
5678        NextVar(index) == index is equivalent to ActiveVar(index) == 0.
5679        """
5680        return _pywrapcp.RoutingModel_NextVar(self, index)
5681
5682    def ActiveVar(self, index):
5683        r""" Returns the active variable of the node corresponding to index."""
5684        return _pywrapcp.RoutingModel_ActiveVar(self, index)
5685
5686    def ActiveVehicleVar(self, vehicle):
5687        r"""
5688        Returns the active variable of the vehicle. It will be equal to 1 iff the
5689        route of the vehicle is not empty, 0 otherwise.
5690        """
5691        return _pywrapcp.RoutingModel_ActiveVehicleVar(self, vehicle)
5692
5693    def VehicleRouteConsideredVar(self, vehicle):
5694        r"""
5695        Returns the variable specifying whether or not the given vehicle route is
5696        considered for costs and constraints. It will be equal to 1 iff the route
5697        of the vehicle is not empty OR vehicle_used_when_empty_[vehicle] is true.
5698        """
5699        return _pywrapcp.RoutingModel_VehicleRouteConsideredVar(self, vehicle)
5700
5701    def VehicleVar(self, index):
5702        r"""
5703        Returns the vehicle variable of the node corresponding to index. Note that
5704        VehicleVar(index) == -1 is equivalent to ActiveVar(index) == 0.
5705        """
5706        return _pywrapcp.RoutingModel_VehicleVar(self, index)
5707
5708    def ResourceVar(self, vehicle, resource_group):
5709        r"""
5710        Returns the resource variable for the given vehicle index in the given
5711        resource group. If a vehicle doesn't require a resource from the
5712        corresponding resource group, then ResourceVar(v, r_g) == -1.
5713        """
5714        return _pywrapcp.RoutingModel_ResourceVar(self, vehicle, resource_group)
5715
5716    def CostVar(self):
5717        r""" Returns the global cost variable which is being minimized."""
5718        return _pywrapcp.RoutingModel_CostVar(self)
5719
5720    def GetArcCostForVehicle(self, from_index, to_index, vehicle):
5721        r"""
5722        Returns the cost of the transit arc between two nodes for a given vehicle.
5723        Input are variable indices of node. This returns 0 if vehicle < 0.
5724        """
5725        return _pywrapcp.RoutingModel_GetArcCostForVehicle(self, from_index, to_index, vehicle)
5726
5727    def CostsAreHomogeneousAcrossVehicles(self):
5728        r""" Whether costs are homogeneous across all vehicles."""
5729        return _pywrapcp.RoutingModel_CostsAreHomogeneousAcrossVehicles(self)
5730
5731    def GetHomogeneousCost(self, from_index, to_index):
5732        r"""
5733        Returns the cost of the segment between two nodes supposing all vehicle
5734        costs are the same (returns the cost for the first vehicle otherwise).
5735        """
5736        return _pywrapcp.RoutingModel_GetHomogeneousCost(self, from_index, to_index)
5737
5738    def GetArcCostForFirstSolution(self, from_index, to_index):
5739        r"""
5740        Returns the cost of the arc in the context of the first solution strategy.
5741        This is typically a simplification of the actual cost; see the .cc.
5742        """
5743        return _pywrapcp.RoutingModel_GetArcCostForFirstSolution(self, from_index, to_index)
5744
5745    def GetArcCostForClass(self, from_index, to_index, cost_class_index):
5746        r"""
5747        Returns the cost of the segment between two nodes for a given cost
5748        class. Input are variable indices of nodes and the cost class.
5749        Unlike GetArcCostForVehicle(), if cost_class is kNoCost, then the
5750        returned cost won't necessarily be zero: only some of the components
5751        of the cost that depend on the cost class will be omited. See the code
5752        for details.
5753        """
5754        return _pywrapcp.RoutingModel_GetArcCostForClass(self, from_index, to_index, cost_class_index)
5755
5756    def GetCostClassIndexOfVehicle(self, vehicle):
5757        r""" Get the cost class index of the given vehicle."""
5758        return _pywrapcp.RoutingModel_GetCostClassIndexOfVehicle(self, vehicle)
5759
5760    def HasVehicleWithCostClassIndex(self, cost_class_index):
5761        r"""
5762        Returns true iff the model contains a vehicle with the given
5763        cost_class_index.
5764        """
5765        return _pywrapcp.RoutingModel_HasVehicleWithCostClassIndex(self, cost_class_index)
5766
5767    def GetCostClassesCount(self):
5768        r""" Returns the number of different cost classes in the model."""
5769        return _pywrapcp.RoutingModel_GetCostClassesCount(self)
5770
5771    def GetNonZeroCostClassesCount(self):
5772        r""" Ditto, minus the 'always zero', built-in cost class."""
5773        return _pywrapcp.RoutingModel_GetNonZeroCostClassesCount(self)
5774
5775    def GetVehicleClassIndexOfVehicle(self, vehicle):
5776        return _pywrapcp.RoutingModel_GetVehicleClassIndexOfVehicle(self, vehicle)
5777
5778    def GetVehicleOfClass(self, vehicle_class):
5779        r"""
5780        Returns a vehicle of the given vehicle class, and -1 if there are no
5781        vehicles for this class.
5782        """
5783        return _pywrapcp.RoutingModel_GetVehicleOfClass(self, vehicle_class)
5784
5785    def GetVehicleClassesCount(self):
5786        r""" Returns the number of different vehicle classes in the model."""
5787        return _pywrapcp.RoutingModel_GetVehicleClassesCount(self)
5788
5789    def GetSameVehicleIndicesOfIndex(self, node):
5790        r""" Returns variable indices of nodes constrained to be on the same route."""
5791        return _pywrapcp.RoutingModel_GetSameVehicleIndicesOfIndex(self, node)
5792
5793    def GetVehicleTypeContainer(self):
5794        return _pywrapcp.RoutingModel_GetVehicleTypeContainer(self)
5795
5796    def ArcIsMoreConstrainedThanArc(self, _from, to1, to2):
5797        r"""
5798        Returns whether the arc from->to1 is more constrained than from->to2,
5799        taking into account, in order:
5800        - whether the destination node isn't an end node
5801        - whether the destination node is mandatory
5802        - whether the destination node is bound to the same vehicle as the source
5803        - the "primary constrained" dimension (see SetPrimaryConstrainedDimension)
5804        It then breaks ties using, in order:
5805        - the arc cost (taking unperformed penalties into account)
5806        - the size of the vehicle vars of "to1" and "to2" (lowest size wins)
5807        - the value: the lowest value of the indices to1 and to2 wins.
5808        See the .cc for details.
5809        The more constrained arc is typically preferable when building a
5810        first solution. This method is intended to be used as a callback for the
5811        BestValueByComparisonSelector value selector.
5812        Args:
5813          from: the variable index of the source node
5814          to1: the variable index of the first candidate destination node.
5815          to2: the variable index of the second candidate destination node.
5816        """
5817        return _pywrapcp.RoutingModel_ArcIsMoreConstrainedThanArc(self, _from, to1, to2)
5818
5819    def DebugOutputAssignment(self, solution_assignment, dimension_to_print):
5820        r"""
5821        Print some debugging information about an assignment, including the
5822        feasible intervals of the CumulVar for dimension "dimension_to_print"
5823        at each step of the routes.
5824        If "dimension_to_print" is omitted, all dimensions will be printed.
5825        """
5826        return _pywrapcp.RoutingModel_DebugOutputAssignment(self, solution_assignment, dimension_to_print)
5827
5828    def solver(self):
5829        r"""
5830        Returns a vector cumul_bounds, for which cumul_bounds[i][j] is a pair
5831        containing the minimum and maximum of the CumulVar of the jth node on
5832        route i.
5833        - cumul_bounds[i][j].first is the minimum.
5834        - cumul_bounds[i][j].second is the maximum.
5835        Returns the underlying constraint solver. Can be used to add extra
5836        constraints and/or modify search algorithms.
5837        """
5838        return _pywrapcp.RoutingModel_solver(self)
5839
5840    def CheckLimit(self, *args):
5841        r"""
5842        Returns true if the search limit has been crossed with the given time
5843        offset.
5844        """
5845        return _pywrapcp.RoutingModel_CheckLimit(self, *args)
5846
5847    def RemainingTime(self):
5848        r""" Returns the time left in the search limit."""
5849        return _pywrapcp.RoutingModel_RemainingTime(self)
5850
5851    def TimeBuffer(self):
5852        r""" Returns the time buffer to safely return a solution."""
5853        return _pywrapcp.RoutingModel_TimeBuffer(self)
5854
5855    def nodes(self):
5856        r"""
5857        Sizes and indices
5858        Returns the number of nodes in the model.
5859        """
5860        return _pywrapcp.RoutingModel_nodes(self)
5861
5862    def vehicles(self):
5863        r""" Returns the number of vehicle routes in the model."""
5864        return _pywrapcp.RoutingModel_vehicles(self)
5865
5866    def Size(self):
5867        r""" Returns the number of next variables in the model."""
5868        return _pywrapcp.RoutingModel_Size(self)
5869
5870    def GetNumberOfDecisionsInFirstSolution(self, search_parameters):
5871        r"""
5872        Returns statistics on first solution search, number of decisions sent to
5873        filters, number of decisions rejected by filters.
5874        """
5875        return _pywrapcp.RoutingModel_GetNumberOfDecisionsInFirstSolution(self, search_parameters)
5876
5877    def GetNumberOfRejectsInFirstSolution(self, search_parameters):
5878        return _pywrapcp.RoutingModel_GetNumberOfRejectsInFirstSolution(self, search_parameters)
5879
5880    def GetAutomaticFirstSolutionStrategy(self):
5881        r""" Returns the automatic first solution strategy selected."""
5882        return _pywrapcp.RoutingModel_GetAutomaticFirstSolutionStrategy(self)
5883
5884    def IsMatchingModel(self):
5885        r""" Returns true if a vehicle/node matching problem is detected."""
5886        return _pywrapcp.RoutingModel_IsMatchingModel(self)
5887
5888    def AreRoutesInterdependent(self, parameters):
5889        r"""
5890        Returns true if routes are interdependent. This means that any
5891        modification to a route might impact another.
5892        """
5893        return _pywrapcp.RoutingModel_AreRoutesInterdependent(self, parameters)
5894
5895    def MakeGuidedSlackFinalizer(self, dimension, initializer):
5896        r"""
5897        The next few members are in the public section only for testing purposes.
5898
5899        MakeGuidedSlackFinalizer creates a DecisionBuilder for the slacks of a
5900        dimension using a callback to choose which values to start with.
5901        The finalizer works only when all next variables in the model have
5902        been fixed. It has the following two characteristics:
5903        1. It follows the routes defined by the nexts variables when choosing a
5904           variable to make a decision on.
5905        2. When it comes to choose a value for the slack of node i, the decision
5906           builder first calls the callback with argument i, and supposingly the
5907           returned value is x it creates decisions slack[i] = x, slack[i] = x +
5908           1, slack[i] = x - 1, slack[i] = x + 2, etc.
5909        """
5910        return _pywrapcp.RoutingModel_MakeGuidedSlackFinalizer(self, dimension, initializer)
5911
5912    def MakeSelfDependentDimensionFinalizer(self, dimension):
5913        r"""
5914        MakeSelfDependentDimensionFinalizer is a finalizer for the slacks of a
5915        self-dependent dimension. It makes an extensive use of the caches of the
5916        state dependent transits.
5917        In detail, MakeSelfDependentDimensionFinalizer returns a composition of a
5918        local search decision builder with a greedy descent operator for the cumul
5919        of the start of each route and a guided slack finalizer. Provided there
5920        are no time windows and the maximum slacks are large enough, once the
5921        cumul of the start of route is fixed, the guided finalizer can find
5922        optimal values of the slacks for the rest of the route in time
5923        proportional to the length of the route. Therefore the composed finalizer
5924        generally works in time O(log(t)*n*m), where t is the latest possible
5925        departute time, n is the number of nodes in the network and m is the
5926        number of vehicles.
5927        """
5928        return _pywrapcp.RoutingModel_MakeSelfDependentDimensionFinalizer(self, dimension)
5929
5930    def GetPathsMetadata(self):
5931        return _pywrapcp.RoutingModel_GetPathsMetadata(self)
RoutingModel(*args)
4683    def __init__(self, *args):
4684        _pywrapcp.RoutingModel_swiginit(self, _pywrapcp.new_RoutingModel(*args))
thisown

The membership flag

ROUTING_NOT_SOLVED = 0

Problem not solved yet (before calling RoutingModel::Solve()).

ROUTING_SUCCESS = 1

Problem solved successfully after calling RoutingModel::Solve().

ROUTING_PARTIAL_SUCCESS_LOCAL_OPTIMUM_NOT_REACHED = 2

Problem solved successfully after calling RoutingModel::Solve(), except that a local optimum has not been reached. Leaving more time would allow improving the solution.

ROUTING_FAIL = 3

No solution found to the problem after calling RoutingModel::Solve().

ROUTING_FAIL_TIMEOUT = 4

Time limit reached before finding a solution with RoutingModel::Solve().

ROUTING_INVALID = 5

Model, model parameters or flags are not valid.

ROUTING_INFEASIBLE = 6

Problem proven to be infeasible.

PICKUP_AND_DELIVERY_NO_ORDER = 0

Any precedence is accepted.

PICKUP_AND_DELIVERY_LIFO = 1

Deliveries must be performed in reverse order of pickups.

PICKUP_AND_DELIVERY_FIFO = 2

Deliveries must be performed in the same order as pickups.

kTransitEvaluatorSignUnknown = 0
kTransitEvaluatorSignPositiveOrZero = 1
kTransitEvaluatorSignNegativeOrZero = 2
def RegisterUnaryTransitVector(self, values):
4690    def RegisterUnaryTransitVector(self, values):
4691        r"""
4692        Registers 'callback' and returns its index.
4693        The sign parameter allows to notify the solver that the callback only
4694        return values of the given sign. This can help the solver, but passing
4695        an incorrect sign may crash in non-opt compilation mode, and yield
4696        incorrect results in opt.
4697        """
4698        return _pywrapcp.RoutingModel_RegisterUnaryTransitVector(self, values)

Registers 'callback' and returns its index. The sign parameter allows to notify the solver that the callback only return values of the given sign. This can help the solver, but passing an incorrect sign may crash in non-opt compilation mode, and yield incorrect results in opt.

def RegisterUnaryTransitCallback(self, *args):
4700    def RegisterUnaryTransitCallback(self, *args):
4701        return _pywrapcp.RoutingModel_RegisterUnaryTransitCallback(self, *args)
def RegisterTransitMatrix(self, values):
4703    def RegisterTransitMatrix(self, values):
4704        return _pywrapcp.RoutingModel_RegisterTransitMatrix(self, values)
def RegisterTransitCallback(self, *args):
4706    def RegisterTransitCallback(self, *args):
4707        return _pywrapcp.RoutingModel_RegisterTransitCallback(self, *args)
def TransitCallback(self, callback_index):
4709    def TransitCallback(self, callback_index):
4710        return _pywrapcp.RoutingModel_TransitCallback(self, callback_index)
def UnaryTransitCallbackOrNull(self, callback_index):
4712    def UnaryTransitCallbackOrNull(self, callback_index):
4713        return _pywrapcp.RoutingModel_UnaryTransitCallbackOrNull(self, callback_index)
def AddDimension( self, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name):
4715    def AddDimension(self, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name):
4716        r"""
4717        Model creation
4718        Methods to add dimensions to routes; dimensions represent quantities
4719        accumulated at nodes along the routes. They represent quantities such as
4720        weights or volumes carried along the route, or distance or times.
4721        Quantities at a node are represented by "cumul" variables and the increase
4722        or decrease of quantities between nodes are represented by "transit"
4723        variables. These variables are linked as follows:
4724        if j == next(i), cumul(j) = cumul(i) + transit(i, j) + slack(i)
4725        where slack is a positive slack variable (can represent waiting times for
4726        a time dimension).
4727        Setting the value of fix_start_cumul_to_zero to true will force the
4728        "cumul" variable of the start node of all vehicles to be equal to 0.
4729        Creates a dimension where the transit variable is constrained to be
4730        equal to evaluator(i, next(i)); 'slack_max' is the upper bound of the
4731        slack variable and 'capacity' is the upper bound of the cumul variables.
4732        'name' is the name used to reference the dimension; this name is used to
4733        get cumul and transit variables from the routing model.
4734        Returns false if a dimension with the same name has already been created
4735        (and doesn't create the new dimension).
4736        Takes ownership of the callback 'evaluator'.
4737        """
4738        return _pywrapcp.RoutingModel_AddDimension(self, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name)

Model creation Methods to add dimensions to routes; dimensions represent quantities accumulated at nodes along the routes. They represent quantities such as weights or volumes carried along the route, or distance or times. Quantities at a node are represented by "cumul" variables and the increase or decrease of quantities between nodes are represented by "transit" variables. These variables are linked as follows: if j == next(i), cumul(j) = cumul(i) + transit(i, j) + slack(i) where slack is a positive slack variable (can represent waiting times for a time dimension). Setting the value of fix_start_cumul_to_zero to true will force the "cumul" variable of the start node of all vehicles to be equal to 0. Creates a dimension where the transit variable is constrained to be equal to evaluator(i, next(i)); 'slack_max' is the upper bound of the slack variable and 'capacity' is the upper bound of the cumul variables. 'name' is the name used to reference the dimension; this name is used to get cumul and transit variables from the routing model. Returns false if a dimension with the same name has already been created (and doesn't create the new dimension). Takes ownership of the callback 'evaluator'.

def AddDimensionWithVehicleTransits( self, evaluator_indices, slack_max, capacity, fix_start_cumul_to_zero, name):
4740    def AddDimensionWithVehicleTransits(self, evaluator_indices, slack_max, capacity, fix_start_cumul_to_zero, name):
4741        return _pywrapcp.RoutingModel_AddDimensionWithVehicleTransits(self, evaluator_indices, slack_max, capacity, fix_start_cumul_to_zero, name)
def AddDimensionWithVehicleCapacity( self, evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name):
4743    def AddDimensionWithVehicleCapacity(self, evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name):
4744        return _pywrapcp.RoutingModel_AddDimensionWithVehicleCapacity(self, evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name)
def AddDimensionWithVehicleTransitAndCapacity( self, evaluator_indices, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name):
4746    def AddDimensionWithVehicleTransitAndCapacity(self, evaluator_indices, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name):
4747        return _pywrapcp.RoutingModel_AddDimensionWithVehicleTransitAndCapacity(self, evaluator_indices, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name)
def AddConstantDimensionWithSlack(self, value, capacity, slack_max, fix_start_cumul_to_zero, name):
4749    def AddConstantDimensionWithSlack(self, value, capacity, slack_max, fix_start_cumul_to_zero, name):
4750        r"""
4751        Creates a dimension where the transit variable is constrained to be
4752        equal to 'value'; 'capacity' is the upper bound of the cumul variables.
4753        'name' is the name used to reference the dimension; this name is used to
4754        get cumul and transit variables from the routing model.
4755        Returns a pair consisting of an index to the registered unary transit
4756        callback and a bool denoting whether the dimension has been created.
4757        It is false if a dimension with the same name has already been created
4758        (and doesn't create the new dimension but still register a new callback).
4759        """
4760        return _pywrapcp.RoutingModel_AddConstantDimensionWithSlack(self, value, capacity, slack_max, fix_start_cumul_to_zero, name)

Creates a dimension where the transit variable is constrained to be equal to 'value'; 'capacity' is the upper bound of the cumul variables. 'name' is the name used to reference the dimension; this name is used to get cumul and transit variables from the routing model. Returns a pair consisting of an index to the registered unary transit callback and a bool denoting whether the dimension has been created. It is false if a dimension with the same name has already been created (and doesn't create the new dimension but still register a new callback).

def AddConstantDimension(self, value, capacity, fix_start_cumul_to_zero, name):
4762    def AddConstantDimension(self, value, capacity, fix_start_cumul_to_zero, name):
4763        return _pywrapcp.RoutingModel_AddConstantDimension(self, value, capacity, fix_start_cumul_to_zero, name)
def AddVectorDimension(self, values, capacity, fix_start_cumul_to_zero, name):
4765    def AddVectorDimension(self, values, capacity, fix_start_cumul_to_zero, name):
4766        r"""
4767        Creates a dimension where the transit variable is constrained to be
4768        equal to 'values[i]' for node i; 'capacity' is the upper bound of
4769        the cumul variables. 'name' is the name used to reference the dimension;
4770        this name is used to get cumul and transit variables from the routing
4771        model.
4772        Returns a pair consisting of an index to the registered unary transit
4773        callback and a bool denoting whether the dimension has been created.
4774        It is false if a dimension with the same name has already been created
4775        (and doesn't create the new dimension but still register a new callback).
4776        """
4777        return _pywrapcp.RoutingModel_AddVectorDimension(self, values, capacity, fix_start_cumul_to_zero, name)

Creates a dimension where the transit variable is constrained to be equal to 'values[i]' for node i; 'capacity' is the upper bound of the cumul variables. 'name' is the name used to reference the dimension; this name is used to get cumul and transit variables from the routing model. Returns a pair consisting of an index to the registered unary transit callback and a bool denoting whether the dimension has been created. It is false if a dimension with the same name has already been created (and doesn't create the new dimension but still register a new callback).

def AddMatrixDimension(self, values, capacity, fix_start_cumul_to_zero, name):
4779    def AddMatrixDimension(self, values, capacity, fix_start_cumul_to_zero, name):
4780        r"""
4781        Creates a dimension where the transit variable is constrained to be
4782        equal to 'values[i][next(i)]' for node i; 'capacity' is the upper bound of
4783        the cumul variables. 'name' is the name used to reference the dimension;
4784        this name is used to get cumul and transit variables from the routing
4785        model.
4786        Returns a pair consisting of an index to the registered transit callback
4787        and a bool denoting whether the dimension has been created.
4788        It is false if a dimension with the same name has already been created
4789        (and doesn't create the new dimension but still register a new callback).
4790        """
4791        return _pywrapcp.RoutingModel_AddMatrixDimension(self, values, capacity, fix_start_cumul_to_zero, name)

Creates a dimension where the transit variable is constrained to be equal to 'values[i][next(i)]' for node i; 'capacity' is the upper bound of the cumul variables. 'name' is the name used to reference the dimension; this name is used to get cumul and transit variables from the routing model. Returns a pair consisting of an index to the registered transit callback and a bool denoting whether the dimension has been created. It is false if a dimension with the same name has already been created (and doesn't create the new dimension but still register a new callback).

def GetAllDimensionNames(self):
4793    def GetAllDimensionNames(self):
4794        r""" Outputs the names of all dimensions added to the routing engine."""
4795        return _pywrapcp.RoutingModel_GetAllDimensionNames(self)

Outputs the names of all dimensions added to the routing engine.

def GetDimensions(self):
4797    def GetDimensions(self):
4798        r""" Returns all dimensions of the model."""
4799        return _pywrapcp.RoutingModel_GetDimensions(self)

Returns all dimensions of the model.

def GetDimensionsWithSoftOrSpanCosts(self):
4801    def GetDimensionsWithSoftOrSpanCosts(self):
4802        r""" Returns dimensions with soft or vehicle span costs."""
4803        return _pywrapcp.RoutingModel_GetDimensionsWithSoftOrSpanCosts(self)

Returns dimensions with soft or vehicle span costs.

def GetDimensionsWithGlobalCumulOptimizers(self):
4805    def GetDimensionsWithGlobalCumulOptimizers(self):
4806        r""" Returns the dimensions which have [global|local]_dimension_optimizers_."""
4807        return _pywrapcp.RoutingModel_GetDimensionsWithGlobalCumulOptimizers(self)

Returns the dimensions which have [global|local]_dimension_optimizers_.

def GetDimensionsWithLocalCumulOptimizers(self):
4809    def GetDimensionsWithLocalCumulOptimizers(self):
4810        return _pywrapcp.RoutingModel_GetDimensionsWithLocalCumulOptimizers(self)
def HasGlobalCumulOptimizer(self, dimension):
4812    def HasGlobalCumulOptimizer(self, dimension):
4813        r""" Returns whether the given dimension has global/local cumul optimizers."""
4814        return _pywrapcp.RoutingModel_HasGlobalCumulOptimizer(self, dimension)

Returns whether the given dimension has global/local cumul optimizers.

def HasLocalCumulOptimizer(self, dimension):
4816    def HasLocalCumulOptimizer(self, dimension):
4817        return _pywrapcp.RoutingModel_HasLocalCumulOptimizer(self, dimension)
def GetMutableGlobalCumulLPOptimizer(self, dimension):
4819    def GetMutableGlobalCumulLPOptimizer(self, dimension):
4820        r"""
4821        Returns the global/local dimension cumul optimizer for a given dimension,
4822        or nullptr if there is none.
4823        """
4824        return _pywrapcp.RoutingModel_GetMutableGlobalCumulLPOptimizer(self, dimension)

Returns the global/local dimension cumul optimizer for a given dimension, or nullptr if there is none.

def GetMutableGlobalCumulMPOptimizer(self, dimension):
4826    def GetMutableGlobalCumulMPOptimizer(self, dimension):
4827        return _pywrapcp.RoutingModel_GetMutableGlobalCumulMPOptimizer(self, dimension)
def GetMutableLocalCumulLPOptimizer(self, dimension):
4829    def GetMutableLocalCumulLPOptimizer(self, dimension):
4830        return _pywrapcp.RoutingModel_GetMutableLocalCumulLPOptimizer(self, dimension)
def GetMutableLocalCumulMPOptimizer(self, dimension):
4832    def GetMutableLocalCumulMPOptimizer(self, dimension):
4833        return _pywrapcp.RoutingModel_GetMutableLocalCumulMPOptimizer(self, dimension)
def HasDimension(self, dimension_name):
4835    def HasDimension(self, dimension_name):
4836        r""" Returns true if a dimension exists for a given dimension name."""
4837        return _pywrapcp.RoutingModel_HasDimension(self, dimension_name)

Returns true if a dimension exists for a given dimension name.

def GetDimensionOrDie(self, dimension_name):
4839    def GetDimensionOrDie(self, dimension_name):
4840        r""" Returns a dimension from its name. Dies if the dimension does not exist."""
4841        return _pywrapcp.RoutingModel_GetDimensionOrDie(self, dimension_name)

Returns a dimension from its name. Dies if the dimension does not exist.

def GetMutableDimension(self, dimension_name):
4843    def GetMutableDimension(self, dimension_name):
4844        r"""
4845        Returns a dimension from its name. Returns nullptr if the dimension does
4846        not exist.
4847        """
4848        return _pywrapcp.RoutingModel_GetMutableDimension(self, dimension_name)

Returns a dimension from its name. Returns nullptr if the dimension does not exist.

def SetPrimaryConstrainedDimension(self, dimension_name):
4850    def SetPrimaryConstrainedDimension(self, dimension_name):
4851        r"""
4852        Set the given dimension as "primary constrained". As of August 2013, this
4853        is only used by ArcIsMoreConstrainedThanArc().
4854        "dimension" must be the name of an existing dimension, or be empty, in
4855        which case there will not be a primary dimension after this call.
4856        """
4857        return _pywrapcp.RoutingModel_SetPrimaryConstrainedDimension(self, dimension_name)

Set the given dimension as "primary constrained". As of August 2013, this is only used by ArcIsMoreConstrainedThanArc(). "dimension" must be the name of an existing dimension, or be empty, in which case there will not be a primary dimension after this call.

def GetPrimaryConstrainedDimension(self):
4859    def GetPrimaryConstrainedDimension(self):
4860        r""" Get the primary constrained dimension, or an empty string if it is unset."""
4861        return _pywrapcp.RoutingModel_GetPrimaryConstrainedDimension(self)

Get the primary constrained dimension, or an empty string if it is unset.

def AddResourceGroup(self):
4863    def AddResourceGroup(self):
4864        r"""
4865        Adds a resource group to the routing model. Returns its index in
4866        resource_groups_.
4867        """
4868        return _pywrapcp.RoutingModel_AddResourceGroup(self)

Adds a resource group to the routing model. Returns its index in resource_groups_.

def GetResourceGroups(self):
4870    def GetResourceGroups(self):
4871        return _pywrapcp.RoutingModel_GetResourceGroups(self)
def GetResourceGroup(self, rg_index):
4873    def GetResourceGroup(self, rg_index):
4874        return _pywrapcp.RoutingModel_GetResourceGroup(self, rg_index)
def GetDimensionResourceGroupIndices(self, dimension):
4876    def GetDimensionResourceGroupIndices(self, dimension):
4877        r"""
4878        Returns the indices of resource groups for this dimension. This method can
4879        only be called after the model has been closed.
4880        """
4881        return _pywrapcp.RoutingModel_GetDimensionResourceGroupIndices(self, dimension)

Returns the indices of resource groups for this dimension. This method can only be called after the model has been closed.

def GetDimensionResourceGroupIndex(self, dimension):
4883    def GetDimensionResourceGroupIndex(self, dimension):
4884        r"""
4885        Returns the index of the resource group attached to the dimension.
4886        DCHECKS that there's exactly one resource group for this dimension.
4887        """
4888        return _pywrapcp.RoutingModel_GetDimensionResourceGroupIndex(self, dimension)

Returns the index of the resource group attached to the dimension. DCHECKS that there's exactly one resource group for this dimension.

def AddDisjunction(self, *args):
4890    def AddDisjunction(self, *args):
4891        r"""
4892        Adds a disjunction constraint on the indices: exactly 'max_cardinality' of
4893        the indices are active. Start and end indices of any vehicle cannot be
4894        part of a disjunction.
4895
4896        If a penalty is given, at most 'max_cardinality' of the indices can be
4897        active, and if less are active, 'penalty' is payed per inactive index.
4898        This is equivalent to adding the constraint:
4899            p + Sum(i)active[i] == max_cardinality
4900        where p is an integer variable, and the following cost to the cost
4901        function:
4902            p * penalty.
4903        'penalty' must be positive to make the disjunction optional; a negative
4904        penalty will force 'max_cardinality' indices of the disjunction to be
4905        performed, and therefore p == 0.
4906        Note: passing a vector with a single index will model an optional index
4907        with a penalty cost if it is not visited.
4908        """
4909        return _pywrapcp.RoutingModel_AddDisjunction(self, *args)

Adds a disjunction constraint on the indices: exactly 'max_cardinality' of the indices are active. Start and end indices of any vehicle cannot be part of a disjunction.

If a penalty is given, at most 'max_cardinality' of the indices can be active, and if less are active, 'penalty' is payed per inactive index.

This is equivalent to adding the constraint:

p + Sum(i)active[i] == max_cardinality

where p is an integer variable, and the following cost to the cost function: p * penalty. 'penalty' must be positive to make the disjunction optional; a negative penalty will force 'max_cardinality' indices of the disjunction to be performed, and therefore p == 0. Note: passing a vector with a single index will model an optional index with a penalty cost if it is not visited.

def GetDisjunctionIndices(self, index):
4911    def GetDisjunctionIndices(self, index):
4912        r""" Returns the indices of the disjunctions to which an index belongs."""
4913        return _pywrapcp.RoutingModel_GetDisjunctionIndices(self, index)

Returns the indices of the disjunctions to which an index belongs.

def GetDisjunctionPenalty(self, index):
4915    def GetDisjunctionPenalty(self, index):
4916        r""" Returns the penalty of the node disjunction of index 'index'."""
4917        return _pywrapcp.RoutingModel_GetDisjunctionPenalty(self, index)

Returns the penalty of the node disjunction of index 'index'.

def GetDisjunctionMaxCardinality(self, index):
4919    def GetDisjunctionMaxCardinality(self, index):
4920        r"""
4921        Returns the maximum number of possible active nodes of the node
4922        disjunction of index 'index'.
4923        """
4924        return _pywrapcp.RoutingModel_GetDisjunctionMaxCardinality(self, index)

Returns the maximum number of possible active nodes of the node disjunction of index 'index'.

def GetNumberOfDisjunctions(self):
4926    def GetNumberOfDisjunctions(self):
4927        r""" Returns the number of node disjunctions in the model."""
4928        return _pywrapcp.RoutingModel_GetNumberOfDisjunctions(self)

Returns the number of node disjunctions in the model.

def HasMandatoryDisjunctions(self):
4930    def HasMandatoryDisjunctions(self):
4931        r"""
4932        Returns true if the model contains mandatory disjunctions (ones with
4933        kNoPenalty as penalty).
4934        """
4935        return _pywrapcp.RoutingModel_HasMandatoryDisjunctions(self)

Returns true if the model contains mandatory disjunctions (ones with kNoPenalty as penalty).

def HasMaxCardinalityConstrainedDisjunctions(self):
4937    def HasMaxCardinalityConstrainedDisjunctions(self):
4938        r"""
4939        Returns true if the model contains at least one disjunction which is
4940        constrained by its max_cardinality.
4941        """
4942        return _pywrapcp.RoutingModel_HasMaxCardinalityConstrainedDisjunctions(self)

Returns true if the model contains at least one disjunction which is constrained by its max_cardinality.

def GetPerfectBinaryDisjunctions(self):
4944    def GetPerfectBinaryDisjunctions(self):
4945        r"""
4946        Returns the list of all perfect binary disjunctions, as pairs of variable
4947        indices: a disjunction is "perfect" when its variables do not appear in
4948        any other disjunction. Each pair is sorted (lowest variable index first),
4949        and the output vector is also sorted (lowest pairs first).
4950        """
4951        return _pywrapcp.RoutingModel_GetPerfectBinaryDisjunctions(self)

Returns the list of all perfect binary disjunctions, as pairs of variable indices: a disjunction is "perfect" when its variables do not appear in any other disjunction. Each pair is sorted (lowest variable index first), and the output vector is also sorted (lowest pairs first).

def IgnoreDisjunctionsAlreadyForcedToZero(self):
4953    def IgnoreDisjunctionsAlreadyForcedToZero(self):
4954        r"""
4955        SPECIAL: Makes the solver ignore all the disjunctions whose active
4956        variables are all trivially zero (i.e. Max() == 0), by setting their
4957        max_cardinality to 0.
4958        This can be useful when using the BaseBinaryDisjunctionNeighborhood
4959        operators, in the context of arc-based routing.
4960        """
4961        return _pywrapcp.RoutingModel_IgnoreDisjunctionsAlreadyForcedToZero(self)

SPECIAL: Makes the solver ignore all the disjunctions whose active variables are all trivially zero (i.e. Max() == 0), by setting their max_cardinality to 0. This can be useful when using the BaseBinaryDisjunctionNeighborhood operators, in the context of arc-based routing.

def AddSoftSameVehicleConstraint(self, indices, cost):
4963    def AddSoftSameVehicleConstraint(self, indices, cost):
4964        r"""
4965        Adds a soft constraint to force a set of variable indices to be on the
4966        same vehicle. If all nodes are not on the same vehicle, each extra vehicle
4967        used adds 'cost' to the cost function.
4968        """
4969        return _pywrapcp.RoutingModel_AddSoftSameVehicleConstraint(self, indices, cost)

Adds a soft constraint to force a set of variable indices to be on the same vehicle. If all nodes are not on the same vehicle, each extra vehicle used adds 'cost' to the cost function.

def SetAllowedVehiclesForIndex(self, vehicles, index):
4971    def SetAllowedVehiclesForIndex(self, vehicles, index):
4972        r"""
4973        Sets the vehicles which can visit a given node. If the node is in a
4974        disjunction, this will not prevent it from being unperformed.
4975        Specifying an empty vector of vehicles has no effect (all vehicles
4976        will be allowed to visit the node).
4977        """
4978        return _pywrapcp.RoutingModel_SetAllowedVehiclesForIndex(self, vehicles, index)

Sets the vehicles which can visit a given node. If the node is in a disjunction, this will not prevent it from being unperformed. Specifying an empty vector of vehicles has no effect (all vehicles will be allowed to visit the node).

def IsVehicleAllowedForIndex(self, vehicle, index):
4980    def IsVehicleAllowedForIndex(self, vehicle, index):
4981        r""" Returns true if a vehicle is allowed to visit a given node."""
4982        return _pywrapcp.RoutingModel_IsVehicleAllowedForIndex(self, vehicle, index)

Returns true if a vehicle is allowed to visit a given node.

def AddPickupAndDelivery(self, pickup, delivery):
4984    def AddPickupAndDelivery(self, pickup, delivery):
4985        r"""
4986        Notifies that index1 and index2 form a pair of nodes which should belong
4987        to the same route. This methods helps the search find better solutions,
4988        especially in the local search phase.
4989        It should be called each time you have an equality constraint linking
4990        the vehicle variables of two node (including for instance pickup and
4991        delivery problems):
4992            Solver* const solver = routing.solver();
4993            int64_t index1 = manager.NodeToIndex(node1);
4994            int64_t index2 = manager.NodeToIndex(node2);
4995            solver->AddConstraint(solver->MakeEquality(
4996                routing.VehicleVar(index1),
4997                routing.VehicleVar(index2)));
4998            routing.AddPickupAndDelivery(index1, index2);
4999        """
5000        return _pywrapcp.RoutingModel_AddPickupAndDelivery(self, pickup, delivery)

Notifies that index1 and index2 form a pair of nodes which should belong to the same route. This methods helps the search find better solutions, especially in the local search phase. It should be called each time you have an equality constraint linking the vehicle variables of two node (including for instance pickup and delivery problems): Solver* const solver = routing.solver(); int64_t index1 = manager.NodeToIndex(node1); int64_t index2 = manager.NodeToIndex(node2); solver->AddConstraint(solver->MakeEquality( routing.VehicleVar(index1), routing.VehicleVar(index2))); routing.AddPickupAndDelivery(index1, index2);

def AddPickupAndDeliverySets(self, pickup_disjunction, delivery_disjunction):
5002    def AddPickupAndDeliverySets(self, pickup_disjunction, delivery_disjunction):
5003        r"""
5004        Same as AddPickupAndDelivery but notifying that the performed node from
5005        the disjunction of index 'pickup_disjunction' is on the same route as the
5006        performed node from the disjunction of index 'delivery_disjunction'.
5007        """
5008        return _pywrapcp.RoutingModel_AddPickupAndDeliverySets(self, pickup_disjunction, delivery_disjunction)

Same as AddPickupAndDelivery but notifying that the performed node from the disjunction of index 'pickup_disjunction' is on the same route as the performed node from the disjunction of index 'delivery_disjunction'.

def GetPickupIndexPairs(self, node_index):
5010    def GetPickupIndexPairs(self, node_index):
5011        r"""
5012        Returns pairs for which the node is a pickup; the first element of each
5013        pair is the index in the pickup and delivery pairs list in which the
5014        pickup appears, the second element is its index in the pickups list.
5015        """
5016        return _pywrapcp.RoutingModel_GetPickupIndexPairs(self, node_index)

Returns pairs for which the node is a pickup; the first element of each pair is the index in the pickup and delivery pairs list in which the pickup appears, the second element is its index in the pickups list.

def GetDeliveryIndexPairs(self, node_index):
5018    def GetDeliveryIndexPairs(self, node_index):
5019        r""" Same as above for deliveries."""
5020        return _pywrapcp.RoutingModel_GetDeliveryIndexPairs(self, node_index)

Same as above for deliveries.

def SetPickupAndDeliveryPolicyOfAllVehicles(self, policy):
5022    def SetPickupAndDeliveryPolicyOfAllVehicles(self, policy):
5023        r"""
5024        Sets the Pickup and delivery policy of all vehicles. It is equivalent to
5025        calling SetPickupAndDeliveryPolicyOfVehicle on all vehicles.
5026        """
5027        return _pywrapcp.RoutingModel_SetPickupAndDeliveryPolicyOfAllVehicles(self, policy)

Sets the Pickup and delivery policy of all vehicles. It is equivalent to calling SetPickupAndDeliveryPolicyOfVehicle on all vehicles.

def SetPickupAndDeliveryPolicyOfVehicle(self, policy, vehicle):
5029    def SetPickupAndDeliveryPolicyOfVehicle(self, policy, vehicle):
5030        return _pywrapcp.RoutingModel_SetPickupAndDeliveryPolicyOfVehicle(self, policy, vehicle)
def GetPickupAndDeliveryPolicyOfVehicle(self, vehicle):
5032    def GetPickupAndDeliveryPolicyOfVehicle(self, vehicle):
5033        return _pywrapcp.RoutingModel_GetPickupAndDeliveryPolicyOfVehicle(self, vehicle)
def GetNumOfSingletonNodes(self):
5035    def GetNumOfSingletonNodes(self):
5036        r"""
5037        Returns the number of non-start/end nodes which do not appear in a
5038        pickup/delivery pair.
5039        """
5040        return _pywrapcp.RoutingModel_GetNumOfSingletonNodes(self)

Returns the number of non-start/end nodes which do not appear in a pickup/delivery pair.

TYPE_ADDED_TO_VEHICLE = 0

When visited, the number of types 'T' on the vehicle increases by one.

ADDED_TYPE_REMOVED_FROM_VEHICLE = 1

When visited, one instance of type 'T' previously added to the route (TYPE_ADDED_TO_VEHICLE), if any, is removed from the vehicle. If the type was not previously added to the route or all added instances have already been removed, this visit has no effect on the types.

TYPE_ON_VEHICLE_UP_TO_VISIT = 2

With the following policy, the visit enforces that type 'T' is considered on the route from its start until this node is visited.

TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED = 3

The visit doesn't have an impact on the number of types 'T' on the route, as it's (virtually) added and removed directly. This policy can be used for visits which are part of an incompatibility or requirement set without affecting the type count on the route.

def SetVisitType(self, index, type, type_policy):
5063    def SetVisitType(self, index, type, type_policy):
5064        return _pywrapcp.RoutingModel_SetVisitType(self, index, type, type_policy)
def GetVisitType(self, index):
5066    def GetVisitType(self, index):
5067        return _pywrapcp.RoutingModel_GetVisitType(self, index)
def GetSingleNodesOfType(self, type):
5069    def GetSingleNodesOfType(self, type):
5070        return _pywrapcp.RoutingModel_GetSingleNodesOfType(self, type)
def GetPairIndicesOfType(self, type):
5072    def GetPairIndicesOfType(self, type):
5073        return _pywrapcp.RoutingModel_GetPairIndicesOfType(self, type)
def GetVisitTypePolicy(self, index):
5075    def GetVisitTypePolicy(self, index):
5076        return _pywrapcp.RoutingModel_GetVisitTypePolicy(self, index)
def CloseVisitTypes(self):
5078    def CloseVisitTypes(self):
5079        r"""
5080        This function should be called once all node visit types have been set and
5081        prior to adding any incompatibilities/requirements.
5082        "close" types.
5083        """
5084        return _pywrapcp.RoutingModel_CloseVisitTypes(self)

This function should be called once all node visit types have been set and prior to adding any incompatibilities/requirements. "close" types.

def GetNumberOfVisitTypes(self):
5086    def GetNumberOfVisitTypes(self):
5087        return _pywrapcp.RoutingModel_GetNumberOfVisitTypes(self)
def AddHardTypeIncompatibility(self, type1, type2):
5089    def AddHardTypeIncompatibility(self, type1, type2):
5090        r"""
5091        Incompatibilities:
5092        Two nodes with "hard" incompatible types cannot share the same route at
5093        all, while with a "temporal" incompatibility they can't be on the same
5094        route at the same time.
5095        """
5096        return _pywrapcp.RoutingModel_AddHardTypeIncompatibility(self, type1, type2)

Incompatibilities: Two nodes with "hard" incompatible types cannot share the same route at all, while with a "temporal" incompatibility they can't be on the same route at the same time.

def AddTemporalTypeIncompatibility(self, type1, type2):
5098    def AddTemporalTypeIncompatibility(self, type1, type2):
5099        return _pywrapcp.RoutingModel_AddTemporalTypeIncompatibility(self, type1, type2)
def GetHardTypeIncompatibilitiesOfType(self, type):
5101    def GetHardTypeIncompatibilitiesOfType(self, type):
5102        r""" Returns visit types incompatible with a given type."""
5103        return _pywrapcp.RoutingModel_GetHardTypeIncompatibilitiesOfType(self, type)

Returns visit types incompatible with a given type.

def GetTemporalTypeIncompatibilitiesOfType(self, type):
5105    def GetTemporalTypeIncompatibilitiesOfType(self, type):
5106        return _pywrapcp.RoutingModel_GetTemporalTypeIncompatibilitiesOfType(self, type)
def HasHardTypeIncompatibilities(self):
5108    def HasHardTypeIncompatibilities(self):
5109        r"""
5110        Returns true iff any hard (resp. temporal) type incompatibilities have
5111        been added to the model.
5112        """
5113        return _pywrapcp.RoutingModel_HasHardTypeIncompatibilities(self)

Returns true iff any hard (resp. temporal) type incompatibilities have been added to the model.

def HasTemporalTypeIncompatibilities(self):
5115    def HasTemporalTypeIncompatibilities(self):
5116        return _pywrapcp.RoutingModel_HasTemporalTypeIncompatibilities(self)
def AddSameVehicleRequiredTypeAlternatives(self, dependent_type, required_type_alternatives):
5118    def AddSameVehicleRequiredTypeAlternatives(self, dependent_type, required_type_alternatives):
5119        r"""
5120        Requirements:
5121        NOTE: As of 2019-04, cycles in the requirement graph are not supported,
5122        and lead to the dependent nodes being skipped if possible (otherwise
5123        the model is considered infeasible).
5124        The following functions specify that "dependent_type" requires at least
5125        one of the types in "required_type_alternatives".
5126
5127        For same-vehicle requirements, a node of dependent type type_D requires at
5128        least one node of type type_R among the required alternatives on the same
5129        route.
5130        """
5131        return _pywrapcp.RoutingModel_AddSameVehicleRequiredTypeAlternatives(self, dependent_type, required_type_alternatives)

Requirements: NOTE: As of 2019-04, cycles in the requirement graph are not supported, and lead to the dependent nodes being skipped if possible (otherwise the model is considered infeasible). The following functions specify that "dependent_type" requires at least one of the types in "required_type_alternatives".

For same-vehicle requirements, a node of dependent type type_D requires at least one node of type type_R among the required alternatives on the same route.

def AddRequiredTypeAlternativesWhenAddingType(self, dependent_type, required_type_alternatives):
5133    def AddRequiredTypeAlternativesWhenAddingType(self, dependent_type, required_type_alternatives):
5134        r"""
5135        If type_D depends on type_R when adding type_D, any node_D of type_D and
5136        VisitTypePolicy TYPE_ADDED_TO_VEHICLE or
5137        TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED requires at least one type_R on its
5138        vehicle at the time node_D is visited.
5139        """
5140        return _pywrapcp.RoutingModel_AddRequiredTypeAlternativesWhenAddingType(self, dependent_type, required_type_alternatives)

If type_D depends on type_R when adding type_D, any node_D of type_D and VisitTypePolicy TYPE_ADDED_TO_VEHICLE or TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED requires at least one type_R on its vehicle at the time node_D is visited.

def AddRequiredTypeAlternativesWhenRemovingType(self, dependent_type, required_type_alternatives):
5142    def AddRequiredTypeAlternativesWhenRemovingType(self, dependent_type, required_type_alternatives):
5143        r"""
5144        The following requirements apply when visiting dependent nodes that remove
5145        their type from the route, i.e. type_R must be on the vehicle when type_D
5146        of VisitTypePolicy ADDED_TYPE_REMOVED_FROM_VEHICLE,
5147        TYPE_ON_VEHICLE_UP_TO_VISIT or TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED is
5148        visited.
5149        """
5150        return _pywrapcp.RoutingModel_AddRequiredTypeAlternativesWhenRemovingType(self, dependent_type, required_type_alternatives)

The following requirements apply when visiting dependent nodes that remove their type from the route, i.e. type_R must be on the vehicle when type_D of VisitTypePolicy ADDED_TYPE_REMOVED_FROM_VEHICLE, TYPE_ON_VEHICLE_UP_TO_VISIT or TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED is visited.

def GetSameVehicleRequiredTypeAlternativesOfType(self, type):
5152    def GetSameVehicleRequiredTypeAlternativesOfType(self, type):
5153        r"""
5154        Returns the set of same-vehicle requirement alternatives for the given
5155        type.
5156        """
5157        return _pywrapcp.RoutingModel_GetSameVehicleRequiredTypeAlternativesOfType(self, type)

Returns the set of same-vehicle requirement alternatives for the given type.

def GetRequiredTypeAlternativesWhenAddingType(self, type):
5159    def GetRequiredTypeAlternativesWhenAddingType(self, type):
5160        r""" Returns the set of requirement alternatives when adding the given type."""
5161        return _pywrapcp.RoutingModel_GetRequiredTypeAlternativesWhenAddingType(self, type)

Returns the set of requirement alternatives when adding the given type.

def GetRequiredTypeAlternativesWhenRemovingType(self, type):
5163    def GetRequiredTypeAlternativesWhenRemovingType(self, type):
5164        r""" Returns the set of requirement alternatives when removing the given type."""
5165        return _pywrapcp.RoutingModel_GetRequiredTypeAlternativesWhenRemovingType(self, type)

Returns the set of requirement alternatives when removing the given type.

def HasSameVehicleTypeRequirements(self):
5167    def HasSameVehicleTypeRequirements(self):
5168        r"""
5169        Returns true iff any same-route (resp. temporal) type requirements have
5170        been added to the model.
5171        """
5172        return _pywrapcp.RoutingModel_HasSameVehicleTypeRequirements(self)

Returns true iff any same-route (resp. temporal) type requirements have been added to the model.

def HasTemporalTypeRequirements(self):
5174    def HasTemporalTypeRequirements(self):
5175        return _pywrapcp.RoutingModel_HasTemporalTypeRequirements(self)
def HasTypeRegulations(self):
5177    def HasTypeRegulations(self):
5178        r"""
5179        Returns true iff the model has any incompatibilities or requirements set
5180        on node types.
5181        """
5182        return _pywrapcp.RoutingModel_HasTypeRegulations(self)

Returns true iff the model has any incompatibilities or requirements set on node types.

def UnperformedPenalty(self, var_index):
5184    def UnperformedPenalty(self, var_index):
5185        r"""
5186        Get the "unperformed" penalty of a node. This is only well defined if the
5187        node is only part of a single Disjunction, and that disjunction has a
5188        penalty. For forced active nodes returns max int64_t. In all other cases,
5189        this returns 0.
5190        """
5191        return _pywrapcp.RoutingModel_UnperformedPenalty(self, var_index)

Get the "unperformed" penalty of a node. This is only well defined if the node is only part of a single Disjunction, and that disjunction has a penalty. For forced active nodes returns max int64_t. In all other cases, this returns 0.

def UnperformedPenaltyOrValue(self, default_value, var_index):
5193    def UnperformedPenaltyOrValue(self, default_value, var_index):
5194        r"""
5195        Same as above except that it returns default_value instead of 0 when
5196        penalty is not well defined (default value is passed as first argument to
5197        simplify the usage of the method in a callback).
5198        """
5199        return _pywrapcp.RoutingModel_UnperformedPenaltyOrValue(self, default_value, var_index)

Same as above except that it returns default_value instead of 0 when penalty is not well defined (default value is passed as first argument to simplify the usage of the method in a callback).

def GetDepot(self):
5201    def GetDepot(self):
5202        r"""
5203        Returns the variable index of the first starting or ending node of all
5204        routes. If all routes start  and end at the same node (single depot), this
5205        is the node returned.
5206        """
5207        return _pywrapcp.RoutingModel_GetDepot(self)

Returns the variable index of the first starting or ending node of all routes. If all routes start and end at the same node (single depot), this is the node returned.

def SetMaximumNumberOfActiveVehicles(self, max_active_vehicles):
5209    def SetMaximumNumberOfActiveVehicles(self, max_active_vehicles):
5210        r"""
5211        Constrains the maximum number of active vehicles, aka the number of
5212        vehicles which do not have an empty route. For instance, this can be used
5213        to limit the number of routes in the case where there are fewer drivers
5214        than vehicles and that the fleet of vehicle is heterogeneous.
5215        """
5216        return _pywrapcp.RoutingModel_SetMaximumNumberOfActiveVehicles(self, max_active_vehicles)

Constrains the maximum number of active vehicles, aka the number of vehicles which do not have an empty route. For instance, this can be used to limit the number of routes in the case where there are fewer drivers than vehicles and that the fleet of vehicle is heterogeneous.

def GetMaximumNumberOfActiveVehicles(self):
5218    def GetMaximumNumberOfActiveVehicles(self):
5219        r""" Returns the maximum number of active vehicles."""
5220        return _pywrapcp.RoutingModel_GetMaximumNumberOfActiveVehicles(self)

Returns the maximum number of active vehicles.

def SetArcCostEvaluatorOfAllVehicles(self, evaluator_index):
5222    def SetArcCostEvaluatorOfAllVehicles(self, evaluator_index):
5223        r"""
5224        Sets the cost function of the model such that the cost of a segment of a
5225        route between node 'from' and 'to' is evaluator(from, to), whatever the
5226        route or vehicle performing the route.
5227        """
5228        return _pywrapcp.RoutingModel_SetArcCostEvaluatorOfAllVehicles(self, evaluator_index)

Sets the cost function of the model such that the cost of a segment of a route between node 'from' and 'to' is evaluator(from, to), whatever the route or vehicle performing the route.

def SetArcCostEvaluatorOfVehicle(self, evaluator_index, vehicle):
5230    def SetArcCostEvaluatorOfVehicle(self, evaluator_index, vehicle):
5231        r""" Sets the cost function for a given vehicle route."""
5232        return _pywrapcp.RoutingModel_SetArcCostEvaluatorOfVehicle(self, evaluator_index, vehicle)

Sets the cost function for a given vehicle route.

def SetFixedCostOfAllVehicles(self, cost):
5234    def SetFixedCostOfAllVehicles(self, cost):
5235        r"""
5236        Sets the fixed cost of all vehicle routes. It is equivalent to calling
5237        SetFixedCostOfVehicle on all vehicle routes.
5238        """
5239        return _pywrapcp.RoutingModel_SetFixedCostOfAllVehicles(self, cost)

Sets the fixed cost of all vehicle routes. It is equivalent to calling SetFixedCostOfVehicle on all vehicle routes.

def SetFixedCostOfVehicle(self, cost, vehicle):
5241    def SetFixedCostOfVehicle(self, cost, vehicle):
5242        r""" Sets the fixed cost of one vehicle route."""
5243        return _pywrapcp.RoutingModel_SetFixedCostOfVehicle(self, cost, vehicle)

Sets the fixed cost of one vehicle route.

def GetFixedCostOfVehicle(self, vehicle):
5245    def GetFixedCostOfVehicle(self, vehicle):
5246        r"""
5247        Returns the route fixed cost taken into account if the route of the
5248        vehicle is not empty, aka there's at least one node on the route other
5249        than the first and last nodes.
5250        """
5251        return _pywrapcp.RoutingModel_GetFixedCostOfVehicle(self, vehicle)

Returns the route fixed cost taken into account if the route of the vehicle is not empty, aka there's at least one node on the route other than the first and last nodes.

def SetPathEnergyCostOfVehicle(self, force, distance, unit_cost, vehicle):
5253    def SetPathEnergyCostOfVehicle(self, force, distance, unit_cost, vehicle):
5254        return _pywrapcp.RoutingModel_SetPathEnergyCostOfVehicle(self, force, distance, unit_cost, vehicle)
def SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor, quadratic_cost_factor):
5256    def SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor, quadratic_cost_factor):
5257        r"""
5258        The following methods set the linear and quadratic cost factors of
5259        vehicles (must be positive values). The default value of these parameters
5260        is zero for all vehicles.
5261
5262        When set, the cost_ of the model will contain terms aiming at reducing the
5263        number of vehicles used in the model, by adding the following to the
5264        objective for every vehicle v:
5265        INDICATOR(v used in the model) *
5266          [linear_cost_factor_of_vehicle_[v]
5267           - quadratic_cost_factor_of_vehicle_[v]*(square of length of route v)]
5268        i.e. for every used vehicle, we add the linear factor as fixed cost, and
5269        subtract the square of the route length multiplied by the quadratic
5270        factor. This second term aims at making the routes as dense as possible.
5271
5272        Sets the linear and quadratic cost factor of all vehicles.
5273        """
5274        return _pywrapcp.RoutingModel_SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor, quadratic_cost_factor)

The following methods set the linear and quadratic cost factors of vehicles (must be positive values). The default value of these parameters is zero for all vehicles.

When set, the cost_ of the model will contain terms aiming at reducing the number of vehicles used in the model, by adding the following to the objective for every vehicle v: INDICATOR(v used in the model) * [linear_cost_factor_of_vehicle_[v]

  • quadratic_cost_factor_of_vehicle_[v]*(square of length of route v)] i.e. for every used vehicle, we add the linear factor as fixed cost, and subtract the square of the route length multiplied by the quadratic factor. This second term aims at making the routes as dense as possible.

Sets the linear and quadratic cost factor of all vehicles.

def SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor, quadratic_cost_factor, vehicle):
5276    def SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor, quadratic_cost_factor, vehicle):
5277        r""" Sets the linear and quadratic cost factor of the given vehicle."""
5278        return _pywrapcp.RoutingModel_SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor, quadratic_cost_factor, vehicle)

Sets the linear and quadratic cost factor of the given vehicle.

def GetAmortizedLinearCostFactorOfVehicles(self):
5280    def GetAmortizedLinearCostFactorOfVehicles(self):
5281        return _pywrapcp.RoutingModel_GetAmortizedLinearCostFactorOfVehicles(self)
def GetAmortizedQuadraticCostFactorOfVehicles(self):
5283    def GetAmortizedQuadraticCostFactorOfVehicles(self):
5284        return _pywrapcp.RoutingModel_GetAmortizedQuadraticCostFactorOfVehicles(self)
def SetVehicleUsedWhenEmpty(self, is_used, vehicle):
5286    def SetVehicleUsedWhenEmpty(self, is_used, vehicle):
5287        return _pywrapcp.RoutingModel_SetVehicleUsedWhenEmpty(self, is_used, vehicle)
def IsVehicleUsedWhenEmpty(self, vehicle):
5289    def IsVehicleUsedWhenEmpty(self, vehicle):
5290        return _pywrapcp.RoutingModel_IsVehicleUsedWhenEmpty(self, vehicle)
def SetFirstSolutionEvaluator(self, evaluator):
5292    def SetFirstSolutionEvaluator(self, evaluator):
5293        r"""
5294        Gets/sets the evaluator used during the search. Only relevant when
5295        RoutingSearchParameters.first_solution_strategy = EVALUATOR_STRATEGY.
5296        Takes ownership of evaluator.
5297        """
5298        return _pywrapcp.RoutingModel_SetFirstSolutionEvaluator(self, evaluator)

Gets/sets the evaluator used during the search. Only relevant when RoutingSearchParameters.first_solution_strategy = EVALUATOR_STRATEGY. Takes ownership of evaluator.

def AddLocalSearchOperator(self, ls_operator):
5300    def AddLocalSearchOperator(self, ls_operator):
5301        r"""
5302        Adds a local search operator to the set of operators used to solve the
5303        vehicle routing problem.
5304        """
5305        return _pywrapcp.RoutingModel_AddLocalSearchOperator(self, ls_operator)

Adds a local search operator to the set of operators used to solve the vehicle routing problem.

def AddSearchMonitor(self, monitor):
5307    def AddSearchMonitor(self, monitor):
5308        r""" Adds a search monitor to the search used to solve the routing model."""
5309        return _pywrapcp.RoutingModel_AddSearchMonitor(self, monitor)

Adds a search monitor to the search used to solve the routing model.

def AddAtSolutionCallback(self, callback, track_unchecked_neighbors=False):
5311    def AddAtSolutionCallback(self, callback, track_unchecked_neighbors=False):
5312        r"""
5313        Adds a callback called each time a solution is found during the search.
5314        This is a shortcut to creating a monitor to call the callback on
5315        AtSolution() and adding it with AddSearchMonitor.
5316        If track_unchecked_neighbors is true, the callback will also be called on
5317        AcceptUncheckedNeighbor() events, which is useful to grab solutions
5318        obtained when solver_parameters.check_solution_period > 1 (aka fastLS).
5319        """
5320        return _pywrapcp.RoutingModel_AddAtSolutionCallback(self, callback, track_unchecked_neighbors)

Adds a callback called each time a solution is found during the search. This is a shortcut to creating a monitor to call the callback on AtSolution() and adding it with AddSearchMonitor. If track_unchecked_neighbors is true, the callback will also be called on AcceptUncheckedNeighbor() events, which is useful to grab solutions obtained when solver_parameters.check_solution_period > 1 (aka fastLS).

def AddVariableMinimizedByFinalizer(self, var):
5322    def AddVariableMinimizedByFinalizer(self, var):
5323        r"""
5324        Adds a variable to minimize in the solution finalizer. The solution
5325        finalizer is called each time a solution is found during the search and
5326        allows to instantiate secondary variables (such as dimension cumul
5327        variables).
5328        """
5329        return _pywrapcp.RoutingModel_AddVariableMinimizedByFinalizer(self, var)

Adds a variable to minimize in the solution finalizer. The solution finalizer is called each time a solution is found during the search and allows to instantiate secondary variables (such as dimension cumul variables).

def AddVariableMaximizedByFinalizer(self, var):
5331    def AddVariableMaximizedByFinalizer(self, var):
5332        r"""
5333        Adds a variable to maximize in the solution finalizer (see above for
5334        information on the solution finalizer).
5335        """
5336        return _pywrapcp.RoutingModel_AddVariableMaximizedByFinalizer(self, var)

Adds a variable to maximize in the solution finalizer (see above for information on the solution finalizer).

def AddWeightedVariableMinimizedByFinalizer(self, var, cost):
5338    def AddWeightedVariableMinimizedByFinalizer(self, var, cost):
5339        r"""
5340        Adds a variable to minimize in the solution finalizer, with a weighted
5341        priority: the higher the more priority it has.
5342        """
5343        return _pywrapcp.RoutingModel_AddWeightedVariableMinimizedByFinalizer(self, var, cost)

Adds a variable to minimize in the solution finalizer, with a weighted priority: the higher the more priority it has.

def AddWeightedVariableMaximizedByFinalizer(self, var, cost):
5345    def AddWeightedVariableMaximizedByFinalizer(self, var, cost):
5346        r"""
5347        Adds a variable to maximize in the solution finalizer, with a weighted
5348        priority: the higher the more priority it has.
5349        """
5350        return _pywrapcp.RoutingModel_AddWeightedVariableMaximizedByFinalizer(self, var, cost)

Adds a variable to maximize in the solution finalizer, with a weighted priority: the higher the more priority it has.

def AddVariableTargetToFinalizer(self, var, target):
5352    def AddVariableTargetToFinalizer(self, var, target):
5353        r"""
5354        Add a variable to set the closest possible to the target value in the
5355        solution finalizer.
5356        """
5357        return _pywrapcp.RoutingModel_AddVariableTargetToFinalizer(self, var, target)

Add a variable to set the closest possible to the target value in the solution finalizer.

def AddWeightedVariableTargetToFinalizer(self, var, target, cost):
5359    def AddWeightedVariableTargetToFinalizer(self, var, target, cost):
5360        r"""
5361        Same as above with a weighted priority: the higher the cost, the more
5362        priority it has to be set close to the target value.
5363        """
5364        return _pywrapcp.RoutingModel_AddWeightedVariableTargetToFinalizer(self, var, target, cost)

Same as above with a weighted priority: the higher the cost, the more priority it has to be set close to the target value.

def CloseModel(self):
5366    def CloseModel(self):
5367        r"""
5368        Closes the current routing model; after this method is called, no
5369        modification to the model can be done, but RoutesToAssignment becomes
5370        available. Note that CloseModel() is automatically called by Solve() and
5371        other methods that produce solution.
5372        This is equivalent to calling
5373        CloseModelWithParameters(DefaultRoutingSearchParameters()).
5374        """
5375        return _pywrapcp.RoutingModel_CloseModel(self)

Closes the current routing model; after this method is called, no modification to the model can be done, but RoutesToAssignment becomes available. Note that CloseModel() is automatically called by Solve() and other methods that produce solution. This is equivalent to calling CloseModelWithParameters(DefaultRoutingSearchParameters()).

def CloseModelWithParameters(self, search_parameters):
5377    def CloseModelWithParameters(self, search_parameters):
5378        r"""
5379        Same as above taking search parameters (as of 10/2015 some the parameters
5380        have to be set when closing the model).
5381        """
5382        return _pywrapcp.RoutingModel_CloseModelWithParameters(self, search_parameters)

Same as above taking search parameters (as of 10/2015 some the parameters have to be set when closing the model).

def Solve(self, assignment=None):
5384    def Solve(self, assignment=None):
5385        r"""
5386        Solves the current routing model; closes the current model.
5387        This is equivalent to calling
5388        SolveWithParameters(DefaultRoutingSearchParameters())
5389        or
5390        SolveFromAssignmentWithParameters(assignment,
5391                                          DefaultRoutingSearchParameters()).
5392        """
5393        return _pywrapcp.RoutingModel_Solve(self, assignment)

Solves the current routing model; closes the current model. This is equivalent to calling SolveWithParameters(DefaultRoutingSearchParameters()) or SolveFromAssignmentWithParameters(assignment, DefaultRoutingSearchParameters()).

def SolveWithParameters(self, search_parameters, solutions=None):
5395    def SolveWithParameters(self, search_parameters, solutions=None):
5396        r"""
5397        Solves the current routing model with the given parameters. If 'solutions'
5398        is specified, it will contain the k best solutions found during the search
5399        (from worst to best, including the one returned by this method), where k
5400        corresponds to the 'number_of_solutions_to_collect' in
5401        'search_parameters'. Note that the Assignment returned by the method and
5402        the ones in solutions are owned by the underlying solver and should not be
5403        deleted.
5404        """
5405        return _pywrapcp.RoutingModel_SolveWithParameters(self, search_parameters, solutions)

Solves the current routing model with the given parameters. If 'solutions' is specified, it will contain the k best solutions found during the search (from worst to best, including the one returned by this method), where k corresponds to the 'number_of_solutions_to_collect' in 'search_parameters'. Note that the Assignment returned by the method and the ones in solutions are owned by the underlying solver and should not be deleted.

def SolveFromAssignmentWithParameters(self, assignment, search_parameters, solutions=None):
5407    def SolveFromAssignmentWithParameters(self, assignment, search_parameters, solutions=None):
5408        r"""
5409        Same as above, except that if assignment is not null, it will be used as
5410        the initial solution.
5411        """
5412        return _pywrapcp.RoutingModel_SolveFromAssignmentWithParameters(self, assignment, search_parameters, solutions)

Same as above, except that if assignment is not null, it will be used as the initial solution.

def SolveFromAssignmentsWithParameters(self, assignments, search_parameters, solutions=None):
5414    def SolveFromAssignmentsWithParameters(self, assignments, search_parameters, solutions=None):
5415        r"""
5416        Same as above but will try all assignments in order as first solutions
5417        until one succeeds.
5418        """
5419        return _pywrapcp.RoutingModel_SolveFromAssignmentsWithParameters(self, assignments, search_parameters, solutions)

Same as above but will try all assignments in order as first solutions until one succeeds.

def SetAssignmentFromOtherModelAssignment(self, target_assignment, source_model, source_assignment):
5421    def SetAssignmentFromOtherModelAssignment(self, target_assignment, source_model, source_assignment):
5422        r"""
5423        Given a "source_model" and its "source_assignment", resets
5424        "target_assignment" with the IntVar variables (nexts_, and vehicle_vars_
5425        if costs aren't homogeneous across vehicles) of "this" model, with the
5426        values set according to those in "other_assignment".
5427        The objective_element of target_assignment is set to this->cost_.
5428        """
5429        return _pywrapcp.RoutingModel_SetAssignmentFromOtherModelAssignment(self, target_assignment, source_model, source_assignment)

Given a "source_model" and its "source_assignment", resets "target_assignment" with the IntVar variables (nexts_, and vehicle_vars_ if costs aren't homogeneous across vehicles) of "this" model, with the values set according to those in "other_assignment". The objective_element of target_assignment is set to this->cost_.

def ComputeLowerBound(self):
5431    def ComputeLowerBound(self):
5432        r"""
5433        Computes a lower bound to the routing problem solving a linear assignment
5434        problem. The routing model must be closed before calling this method.
5435        Note that problems with node disjunction constraints (including optional
5436        nodes) and non-homogenous costs are not supported (the method returns 0 in
5437        these cases).
5438        """
5439        return _pywrapcp.RoutingModel_ComputeLowerBound(self)

Computes a lower bound to the routing problem solving a linear assignment problem. The routing model must be closed before calling this method. Note that problems with node disjunction constraints (including optional nodes) and non-homogenous costs are not supported (the method returns 0 in these cases).

def status(self):
5441    def status(self):
5442        r""" Returns the current status of the routing model."""
5443        return _pywrapcp.RoutingModel_status(self)

Returns the current status of the routing model.

def enable_deep_serialization(self):
5445    def enable_deep_serialization(self):
5446        r""" Returns the value of the internal enable_deep_serialization_ parameter."""
5447        return _pywrapcp.RoutingModel_enable_deep_serialization(self)

Returns the value of the internal enable_deep_serialization_ parameter.

def ApplyLocks(self, locks):
5449    def ApplyLocks(self, locks):
5450        r"""
5451        Applies a lock chain to the next search. 'locks' represents an ordered
5452        vector of nodes representing a partial route which will be fixed during
5453        the next search; it will constrain next variables such that:
5454        next[locks[i]] == locks[i+1].
5455
5456        Returns the next variable at the end of the locked chain; this variable is
5457        not locked. An assignment containing the locks can be obtained by calling
5458        PreAssignment().
5459        """
5460        return _pywrapcp.RoutingModel_ApplyLocks(self, locks)

Applies a lock chain to the next search. 'locks' represents an ordered vector of nodes representing a partial route which will be fixed during the next search; it will constrain next variables such that: next[locks[i]] == locks[i+1].

Returns the next variable at the end of the locked chain; this variable is not locked. An assignment containing the locks can be obtained by calling PreAssignment().

def ApplyLocksToAllVehicles(self, locks, close_routes):
5462    def ApplyLocksToAllVehicles(self, locks, close_routes):
5463        r"""
5464        Applies lock chains to all vehicles to the next search, such that locks[p]
5465        is the lock chain for route p. Returns false if the locks do not contain
5466        valid routes; expects that the routes do not contain the depots,
5467        i.e. there are empty vectors in place of empty routes.
5468        If close_routes is set to true, adds the end nodes to the route of each
5469        vehicle and deactivates other nodes.
5470        An assignment containing the locks can be obtained by calling
5471        PreAssignment().
5472        """
5473        return _pywrapcp.RoutingModel_ApplyLocksToAllVehicles(self, locks, close_routes)

Applies lock chains to all vehicles to the next search, such that locks[p] is the lock chain for route p. Returns false if the locks do not contain valid routes; expects that the routes do not contain the depots, i.e. there are empty vectors in place of empty routes. If close_routes is set to true, adds the end nodes to the route of each vehicle and deactivates other nodes. An assignment containing the locks can be obtained by calling PreAssignment().

def PreAssignment(self):
5475    def PreAssignment(self):
5476        r"""
5477        Returns an assignment used to fix some of the variables of the problem.
5478        In practice, this assignment locks partial routes of the problem. This
5479        can be used in the context of locking the parts of the routes which have
5480        already been driven in online routing problems.
5481        """
5482        return _pywrapcp.RoutingModel_PreAssignment(self)

Returns an assignment used to fix some of the variables of the problem. In practice, this assignment locks partial routes of the problem. This can be used in the context of locking the parts of the routes which have already been driven in online routing problems.

def MutablePreAssignment(self):
5484    def MutablePreAssignment(self):
5485        return _pywrapcp.RoutingModel_MutablePreAssignment(self)
def WriteAssignment(self, file_name):
5487    def WriteAssignment(self, file_name):
5488        r"""
5489        Writes the current solution to a file containing an AssignmentProto.
5490        Returns false if the file cannot be opened or if there is no current
5491        solution.
5492        """
5493        return _pywrapcp.RoutingModel_WriteAssignment(self, file_name)

Writes the current solution to a file containing an AssignmentProto. Returns false if the file cannot be opened or if there is no current solution.

def ReadAssignment(self, file_name):
5495    def ReadAssignment(self, file_name):
5496        r"""
5497        Reads an assignment from a file and returns the current solution.
5498        Returns nullptr if the file cannot be opened or if the assignment is not
5499        valid.
5500        """
5501        return _pywrapcp.RoutingModel_ReadAssignment(self, file_name)

Reads an assignment from a file and returns the current solution. Returns nullptr if the file cannot be opened or if the assignment is not valid.

def RestoreAssignment(self, solution):
5503    def RestoreAssignment(self, solution):
5504        r"""
5505        Restores an assignment as a solution in the routing model and returns the
5506        new solution. Returns nullptr if the assignment is not valid.
5507        """
5508        return _pywrapcp.RoutingModel_RestoreAssignment(self, solution)

Restores an assignment as a solution in the routing model and returns the new solution. Returns nullptr if the assignment is not valid.

def ReadAssignmentFromRoutes(self, routes, ignore_inactive_indices):
5510    def ReadAssignmentFromRoutes(self, routes, ignore_inactive_indices):
5511        r"""
5512        Restores the routes as the current solution. Returns nullptr if the
5513        solution cannot be restored (routes do not contain a valid solution). Note
5514        that calling this method will run the solver to assign values to the
5515        dimension variables; this may take considerable amount of time, especially
5516        when using dimensions with slack.
5517        """
5518        return _pywrapcp.RoutingModel_ReadAssignmentFromRoutes(self, routes, ignore_inactive_indices)

Restores the routes as the current solution. Returns nullptr if the solution cannot be restored (routes do not contain a valid solution). Note that calling this method will run the solver to assign values to the dimension variables; this may take considerable amount of time, especially when using dimensions with slack.

def RoutesToAssignment(self, routes, ignore_inactive_indices, close_routes, assignment):
5520    def RoutesToAssignment(self, routes, ignore_inactive_indices, close_routes, assignment):
5521        r"""
5522        Fills an assignment from a specification of the routes of the
5523        vehicles. The routes are specified as lists of variable indices that
5524        appear on the routes of the vehicles. The indices of the outer vector in
5525        'routes' correspond to vehicles IDs, the inner vector contains the
5526        variable indices on the routes for the given vehicle. The inner vectors
5527        must not contain the start and end indices, as these are determined by the
5528        routing model.  Sets the value of NextVars in the assignment, adding the
5529        variables to the assignment if necessary. The method does not touch other
5530        variables in the assignment. The method can only be called after the model
5531        is closed.  With ignore_inactive_indices set to false, this method will
5532        fail (return nullptr) in case some of the route contain indices that are
5533        deactivated in the model; when set to true, these indices will be
5534        skipped.  Returns true if routes were successfully
5535        loaded. However, such assignment still might not be a valid
5536        solution to the routing problem due to more complex constraints;
5537        it is advisible to call solver()->CheckSolution() afterwards.
5538        """
5539        return _pywrapcp.RoutingModel_RoutesToAssignment(self, routes, ignore_inactive_indices, close_routes, assignment)

Fills an assignment from a specification of the routes of the vehicles. The routes are specified as lists of variable indices that appear on the routes of the vehicles. The indices of the outer vector in 'routes' correspond to vehicles IDs, the inner vector contains the variable indices on the routes for the given vehicle. The inner vectors must not contain the start and end indices, as these are determined by the routing model. Sets the value of NextVars in the assignment, adding the variables to the assignment if necessary. The method does not touch other variables in the assignment. The method can only be called after the model is closed. With ignore_inactive_indices set to false, this method will fail (return nullptr) in case some of the route contain indices that are deactivated in the model; when set to true, these indices will be skipped. Returns true if routes were successfully loaded. However, such assignment still might not be a valid solution to the routing problem due to more complex constraints; it is advisible to call solver()->CheckSolution() afterwards.

def AssignmentToRoutes(self, assignment, routes):
5541    def AssignmentToRoutes(self, assignment, routes):
5542        r"""
5543        Converts the solution in the given assignment to routes for all vehicles.
5544        Expects that assignment contains a valid solution (i.e. routes for all
5545        vehicles end with an end index for that vehicle).
5546        """
5547        return _pywrapcp.RoutingModel_AssignmentToRoutes(self, assignment, routes)

Converts the solution in the given assignment to routes for all vehicles. Expects that assignment contains a valid solution (i.e. routes for all vehicles end with an end index for that vehicle).

def CompactAssignment(self, assignment):
5549    def CompactAssignment(self, assignment):
5550        r"""
5551        Converts the solution in the given assignment to routes for all vehicles.
5552        If the returned vector is route_indices, route_indices[i][j] is the index
5553        for jth location visited on route i. Note that contrary to
5554        AssignmentToRoutes, the vectors do include start and end locations.
5555        Returns a compacted version of the given assignment, in which all vehicles
5556        with id lower or equal to some N have non-empty routes, and all vehicles
5557        with id greater than N have empty routes. Does not take ownership of the
5558        returned object.
5559        If found, the cost of the compact assignment is the same as in the
5560        original assignment and it preserves the values of 'active' variables.
5561        Returns nullptr if a compact assignment was not found.
5562        This method only works in homogenous mode, and it only swaps equivalent
5563        vehicles (vehicles with the same start and end nodes). When creating the
5564        compact assignment, the empty plan is replaced by the route assigned to
5565        the compatible vehicle with the highest id. Note that with more complex
5566        constraints on vehicle variables, this method might fail even if a compact
5567        solution exists.
5568        This method changes the vehicle and dimension variables as necessary.
5569        While compacting the solution, only basic checks on vehicle variables are
5570        performed; if one of these checks fails no attempts to repair it are made
5571        (instead, the method returns nullptr).
5572        """
5573        return _pywrapcp.RoutingModel_CompactAssignment(self, assignment)

Converts the solution in the given assignment to routes for all vehicles. If the returned vector is route_indices, route_indices[i][j] is the index for jth location visited on route i. Note that contrary to AssignmentToRoutes, the vectors do include start and end locations. Returns a compacted version of the given assignment, in which all vehicles with id lower or equal to some N have non-empty routes, and all vehicles with id greater than N have empty routes. Does not take ownership of the returned object. If found, the cost of the compact assignment is the same as in the original assignment and it preserves the values of 'active' variables. Returns nullptr if a compact assignment was not found. This method only works in homogenous mode, and it only swaps equivalent vehicles (vehicles with the same start and end nodes). When creating the compact assignment, the empty plan is replaced by the route assigned to the compatible vehicle with the highest id. Note that with more complex constraints on vehicle variables, this method might fail even if a compact solution exists. This method changes the vehicle and dimension variables as necessary. While compacting the solution, only basic checks on vehicle variables are performed; if one of these checks fails no attempts to repair it are made (instead, the method returns nullptr).

def CompactAndCheckAssignment(self, assignment):
5575    def CompactAndCheckAssignment(self, assignment):
5576        r"""
5577        Same as CompactAssignment() but also checks the validity of the final
5578        compact solution; if it is not valid, no attempts to repair it are made
5579        (instead, the method returns nullptr).
5580        """
5581        return _pywrapcp.RoutingModel_CompactAndCheckAssignment(self, assignment)

Same as CompactAssignment() but also checks the validity of the final compact solution; if it is not valid, no attempts to repair it are made (instead, the method returns nullptr).

def AddToAssignment(self, var):
5583    def AddToAssignment(self, var):
5584        r""" Adds an extra variable to the vehicle routing assignment."""
5585        return _pywrapcp.RoutingModel_AddToAssignment(self, var)

Adds an extra variable to the vehicle routing assignment.

def AddIntervalToAssignment(self, interval):
5587    def AddIntervalToAssignment(self, interval):
5588        return _pywrapcp.RoutingModel_AddIntervalToAssignment(self, interval)
def PackCumulsOfOptimizerDimensionsFromAssignment( self, original_assignment, duration_limit, time_limit_was_reached=None):
5590    def PackCumulsOfOptimizerDimensionsFromAssignment(self, original_assignment, duration_limit, time_limit_was_reached=None):
5591        r"""
5592        For every dimension in the model with an optimizer in
5593        local/global_dimension_optimizers_, this method tries to pack the cumul
5594        values of the dimension, such that:
5595        - The cumul costs (span costs, soft lower and upper bound costs, etc) are
5596          minimized.
5597        - The cumuls of the ends of the routes are minimized for this given
5598          minimal cumul cost.
5599        - Given these minimal end cumuls, the route start cumuls are maximized.
5600        Returns the assignment resulting from allocating these packed cumuls with
5601        the solver, and nullptr if these cumuls could not be set by the solver.
5602        """
5603        return _pywrapcp.RoutingModel_PackCumulsOfOptimizerDimensionsFromAssignment(self, original_assignment, duration_limit, time_limit_was_reached)

For every dimension in the model with an optimizer in local/global_dimension_optimizers_, this method tries to pack the cumul values of the dimension, such that:

  • The cumul costs (span costs, soft lower and upper bound costs, etc) are minimized.
  • The cumuls of the ends of the routes are minimized for this given minimal cumul cost.
  • Given these minimal end cumuls, the route start cumuls are maximized. Returns the assignment resulting from allocating these packed cumuls with the solver, and nullptr if these cumuls could not be set by the solver.
def GetOrCreateNodeNeighborsByCostClass(self, *args):
5605    def GetOrCreateNodeNeighborsByCostClass(self, *args):
5606        r"""
5607        *Overload 1:*
5608        Returns neighbors of all nodes for every cost class. The result is cached
5609        and is computed once. The number of neighbors considered is based on a
5610        ratio of non-vehicle nodes, specified by neighbors_ratio, with a minimum
5611        of min-neighbors node considered.
5612
5613        |
5614
5615        *Overload 2:*
5616        Returns parameters.num_neighbors neighbors of all nodes for every cost
5617        class. The result is cached and is computed once.
5618
5619        |
5620
5621        *Overload 3:*
5622        Returns parameters.num_neighbors neighbors of all nodes for every cost
5623        class. The result is cached and is computed once.
5624        """
5625        return _pywrapcp.RoutingModel_GetOrCreateNodeNeighborsByCostClass(self, *args)

Overload 1: Returns neighbors of all nodes for every cost class. The result is cached and is computed once. The number of neighbors considered is based on a ratio of non-vehicle nodes, specified by neighbors_ratio, with a minimum of min-neighbors node considered.

|

Overload 2: Returns parameters.num_neighbors neighbors of all nodes for every cost class. The result is cached and is computed once.

|

Overload 3: Returns parameters.num_neighbors neighbors of all nodes for every cost class. The result is cached and is computed once.

def AddLocalSearchFilter(self, filter):
5627    def AddLocalSearchFilter(self, filter):
5628        r"""
5629        Adds a custom local search filter to the list of filters used to speed up
5630        local search by pruning unfeasible variable assignments.
5631        Calling this method after the routing model has been closed (CloseModel()
5632        or Solve() has been called) has no effect.
5633        The routing model does not take ownership of the filter.
5634        """
5635        return _pywrapcp.RoutingModel_AddLocalSearchFilter(self, filter)

Adds a custom local search filter to the list of filters used to speed up local search by pruning unfeasible variable assignments. Calling this method after the routing model has been closed (CloseModel() or Solve() has been called) has no effect. The routing model does not take ownership of the filter.

def Start(self, vehicle):
5637    def Start(self, vehicle):
5638        r"""
5639        Model inspection.
5640        Returns the variable index of the starting node of a vehicle route.
5641        """
5642        return _pywrapcp.RoutingModel_Start(self, vehicle)

Model inspection. Returns the variable index of the starting node of a vehicle route.

def End(self, vehicle):
5644    def End(self, vehicle):
5645        r""" Returns the variable index of the ending node of a vehicle route."""
5646        return _pywrapcp.RoutingModel_End(self, vehicle)

Returns the variable index of the ending node of a vehicle route.

def IsStart(self, index):
5648    def IsStart(self, index):
5649        r""" Returns true if 'index' represents the first node of a route."""
5650        return _pywrapcp.RoutingModel_IsStart(self, index)

Returns true if 'index' represents the first node of a route.

def IsEnd(self, index):
5652    def IsEnd(self, index):
5653        r""" Returns true if 'index' represents the last node of a route."""
5654        return _pywrapcp.RoutingModel_IsEnd(self, index)

Returns true if 'index' represents the last node of a route.

def VehicleIndex(self, index):
5656    def VehicleIndex(self, index):
5657        r"""
5658        Returns the vehicle of the given start/end index, and -1 if the given
5659        index is not a vehicle start/end.
5660        """
5661        return _pywrapcp.RoutingModel_VehicleIndex(self, index)

Returns the vehicle of the given start/end index, and -1 if the given index is not a vehicle start/end.

def Next(self, assignment, index):
5663    def Next(self, assignment, index):
5664        r"""
5665        Assignment inspection
5666        Returns the variable index of the node directly after the node
5667        corresponding to 'index' in 'assignment'.
5668        """
5669        return _pywrapcp.RoutingModel_Next(self, assignment, index)

Assignment inspection Returns the variable index of the node directly after the node corresponding to 'index' in 'assignment'.

def IsVehicleUsed(self, assignment, vehicle):
5671    def IsVehicleUsed(self, assignment, vehicle):
5672        r""" Returns true if the route of 'vehicle' is non empty in 'assignment'."""
5673        return _pywrapcp.RoutingModel_IsVehicleUsed(self, assignment, vehicle)

Returns true if the route of 'vehicle' is non empty in 'assignment'.

def NextVar(self, index):
5675    def NextVar(self, index):
5676        r"""
5677        Returns the next variable of the node corresponding to index. Note that
5678        NextVar(index) == index is equivalent to ActiveVar(index) == 0.
5679        """
5680        return _pywrapcp.RoutingModel_NextVar(self, index)

Returns the next variable of the node corresponding to index. Note that NextVar(index) == index is equivalent to ActiveVar(index) == 0.

def ActiveVar(self, index):
5682    def ActiveVar(self, index):
5683        r""" Returns the active variable of the node corresponding to index."""
5684        return _pywrapcp.RoutingModel_ActiveVar(self, index)

Returns the active variable of the node corresponding to index.

def ActiveVehicleVar(self, vehicle):
5686    def ActiveVehicleVar(self, vehicle):
5687        r"""
5688        Returns the active variable of the vehicle. It will be equal to 1 iff the
5689        route of the vehicle is not empty, 0 otherwise.
5690        """
5691        return _pywrapcp.RoutingModel_ActiveVehicleVar(self, vehicle)

Returns the active variable of the vehicle. It will be equal to 1 iff the route of the vehicle is not empty, 0 otherwise.

def VehicleRouteConsideredVar(self, vehicle):
5693    def VehicleRouteConsideredVar(self, vehicle):
5694        r"""
5695        Returns the variable specifying whether or not the given vehicle route is
5696        considered for costs and constraints. It will be equal to 1 iff the route
5697        of the vehicle is not empty OR vehicle_used_when_empty_[vehicle] is true.
5698        """
5699        return _pywrapcp.RoutingModel_VehicleRouteConsideredVar(self, vehicle)

Returns the variable specifying whether or not the given vehicle route is considered for costs and constraints. It will be equal to 1 iff the route of the vehicle is not empty OR vehicle_used_when_empty_[vehicle] is true.

def VehicleVar(self, index):
5701    def VehicleVar(self, index):
5702        r"""
5703        Returns the vehicle variable of the node corresponding to index. Note that
5704        VehicleVar(index) == -1 is equivalent to ActiveVar(index) == 0.
5705        """
5706        return _pywrapcp.RoutingModel_VehicleVar(self, index)

Returns the vehicle variable of the node corresponding to index. Note that VehicleVar(index) == -1 is equivalent to ActiveVar(index) == 0.

def ResourceVar(self, vehicle, resource_group):
5708    def ResourceVar(self, vehicle, resource_group):
5709        r"""
5710        Returns the resource variable for the given vehicle index in the given
5711        resource group. If a vehicle doesn't require a resource from the
5712        corresponding resource group, then ResourceVar(v, r_g) == -1.
5713        """
5714        return _pywrapcp.RoutingModel_ResourceVar(self, vehicle, resource_group)

Returns the resource variable for the given vehicle index in the given resource group. If a vehicle doesn't require a resource from the corresponding resource group, then ResourceVar(v, r_g) == -1.

def CostVar(self):
5716    def CostVar(self):
5717        r""" Returns the global cost variable which is being minimized."""
5718        return _pywrapcp.RoutingModel_CostVar(self)

Returns the global cost variable which is being minimized.

def GetArcCostForVehicle(self, from_index, to_index, vehicle):
5720    def GetArcCostForVehicle(self, from_index, to_index, vehicle):
5721        r"""
5722        Returns the cost of the transit arc between two nodes for a given vehicle.
5723        Input are variable indices of node. This returns 0 if vehicle < 0.
5724        """
5725        return _pywrapcp.RoutingModel_GetArcCostForVehicle(self, from_index, to_index, vehicle)

Returns the cost of the transit arc between two nodes for a given vehicle. Input are variable indices of node. This returns 0 if vehicle < 0.

def CostsAreHomogeneousAcrossVehicles(self):
5727    def CostsAreHomogeneousAcrossVehicles(self):
5728        r""" Whether costs are homogeneous across all vehicles."""
5729        return _pywrapcp.RoutingModel_CostsAreHomogeneousAcrossVehicles(self)

Whether costs are homogeneous across all vehicles.

def GetHomogeneousCost(self, from_index, to_index):
5731    def GetHomogeneousCost(self, from_index, to_index):
5732        r"""
5733        Returns the cost of the segment between two nodes supposing all vehicle
5734        costs are the same (returns the cost for the first vehicle otherwise).
5735        """
5736        return _pywrapcp.RoutingModel_GetHomogeneousCost(self, from_index, to_index)

Returns the cost of the segment between two nodes supposing all vehicle costs are the same (returns the cost for the first vehicle otherwise).

def GetArcCostForFirstSolution(self, from_index, to_index):
5738    def GetArcCostForFirstSolution(self, from_index, to_index):
5739        r"""
5740        Returns the cost of the arc in the context of the first solution strategy.
5741        This is typically a simplification of the actual cost; see the .cc.
5742        """
5743        return _pywrapcp.RoutingModel_GetArcCostForFirstSolution(self, from_index, to_index)

Returns the cost of the arc in the context of the first solution strategy. This is typically a simplification of the actual cost; see the .cc.

def GetArcCostForClass(self, from_index, to_index, cost_class_index):
5745    def GetArcCostForClass(self, from_index, to_index, cost_class_index):
5746        r"""
5747        Returns the cost of the segment between two nodes for a given cost
5748        class. Input are variable indices of nodes and the cost class.
5749        Unlike GetArcCostForVehicle(), if cost_class is kNoCost, then the
5750        returned cost won't necessarily be zero: only some of the components
5751        of the cost that depend on the cost class will be omited. See the code
5752        for details.
5753        """
5754        return _pywrapcp.RoutingModel_GetArcCostForClass(self, from_index, to_index, cost_class_index)

Returns the cost of the segment between two nodes for a given cost class. Input are variable indices of nodes and the cost class. Unlike GetArcCostForVehicle(), if cost_class is kNoCost, then the returned cost won't necessarily be zero: only some of the components of the cost that depend on the cost class will be omited. See the code for details.

def GetCostClassIndexOfVehicle(self, vehicle):
5756    def GetCostClassIndexOfVehicle(self, vehicle):
5757        r""" Get the cost class index of the given vehicle."""
5758        return _pywrapcp.RoutingModel_GetCostClassIndexOfVehicle(self, vehicle)

Get the cost class index of the given vehicle.

def HasVehicleWithCostClassIndex(self, cost_class_index):
5760    def HasVehicleWithCostClassIndex(self, cost_class_index):
5761        r"""
5762        Returns true iff the model contains a vehicle with the given
5763        cost_class_index.
5764        """
5765        return _pywrapcp.RoutingModel_HasVehicleWithCostClassIndex(self, cost_class_index)

Returns true iff the model contains a vehicle with the given cost_class_index.

def GetCostClassesCount(self):
5767    def GetCostClassesCount(self):
5768        r""" Returns the number of different cost classes in the model."""
5769        return _pywrapcp.RoutingModel_GetCostClassesCount(self)

Returns the number of different cost classes in the model.

def GetNonZeroCostClassesCount(self):
5771    def GetNonZeroCostClassesCount(self):
5772        r""" Ditto, minus the 'always zero', built-in cost class."""
5773        return _pywrapcp.RoutingModel_GetNonZeroCostClassesCount(self)

Ditto, minus the 'always zero', built-in cost class.

def GetVehicleClassIndexOfVehicle(self, vehicle):
5775    def GetVehicleClassIndexOfVehicle(self, vehicle):
5776        return _pywrapcp.RoutingModel_GetVehicleClassIndexOfVehicle(self, vehicle)
def GetVehicleOfClass(self, vehicle_class):
5778    def GetVehicleOfClass(self, vehicle_class):
5779        r"""
5780        Returns a vehicle of the given vehicle class, and -1 if there are no
5781        vehicles for this class.
5782        """
5783        return _pywrapcp.RoutingModel_GetVehicleOfClass(self, vehicle_class)

Returns a vehicle of the given vehicle class, and -1 if there are no vehicles for this class.

def GetVehicleClassesCount(self):
5785    def GetVehicleClassesCount(self):
5786        r""" Returns the number of different vehicle classes in the model."""
5787        return _pywrapcp.RoutingModel_GetVehicleClassesCount(self)

Returns the number of different vehicle classes in the model.

def GetSameVehicleIndicesOfIndex(self, node):
5789    def GetSameVehicleIndicesOfIndex(self, node):
5790        r""" Returns variable indices of nodes constrained to be on the same route."""
5791        return _pywrapcp.RoutingModel_GetSameVehicleIndicesOfIndex(self, node)

Returns variable indices of nodes constrained to be on the same route.

def GetVehicleTypeContainer(self):
5793    def GetVehicleTypeContainer(self):
5794        return _pywrapcp.RoutingModel_GetVehicleTypeContainer(self)
def ArcIsMoreConstrainedThanArc(self, _from, to1, to2):
5796    def ArcIsMoreConstrainedThanArc(self, _from, to1, to2):
5797        r"""
5798        Returns whether the arc from->to1 is more constrained than from->to2,
5799        taking into account, in order:
5800        - whether the destination node isn't an end node
5801        - whether the destination node is mandatory
5802        - whether the destination node is bound to the same vehicle as the source
5803        - the "primary constrained" dimension (see SetPrimaryConstrainedDimension)
5804        It then breaks ties using, in order:
5805        - the arc cost (taking unperformed penalties into account)
5806        - the size of the vehicle vars of "to1" and "to2" (lowest size wins)
5807        - the value: the lowest value of the indices to1 and to2 wins.
5808        See the .cc for details.
5809        The more constrained arc is typically preferable when building a
5810        first solution. This method is intended to be used as a callback for the
5811        BestValueByComparisonSelector value selector.
5812        Args:
5813          from: the variable index of the source node
5814          to1: the variable index of the first candidate destination node.
5815          to2: the variable index of the second candidate destination node.
5816        """
5817        return _pywrapcp.RoutingModel_ArcIsMoreConstrainedThanArc(self, _from, to1, to2)

Returns whether the arc from->to1 is more constrained than from->to2, taking into account, in order:

  • whether the destination node isn't an end node
  • whether the destination node is mandatory
  • whether the destination node is bound to the same vehicle as the source
  • the "primary constrained" dimension (see SetPrimaryConstrainedDimension) It then breaks ties using, in order:
  • the arc cost (taking unperformed penalties into account)
  • the size of the vehicle vars of "to1" and "to2" (lowest size wins)
  • the value: the lowest value of the indices to1 and to2 wins. See the .cc for details. The more constrained arc is typically preferable when building a first solution. This method is intended to be used as a callback for the BestValueByComparisonSelector value selector.
Arguments:
  • from: the variable index of the source node
  • to1: the variable index of the first candidate destination node.
  • to2: the variable index of the second candidate destination node.
def DebugOutputAssignment(self, solution_assignment, dimension_to_print):
5819    def DebugOutputAssignment(self, solution_assignment, dimension_to_print):
5820        r"""
5821        Print some debugging information about an assignment, including the
5822        feasible intervals of the CumulVar for dimension "dimension_to_print"
5823        at each step of the routes.
5824        If "dimension_to_print" is omitted, all dimensions will be printed.
5825        """
5826        return _pywrapcp.RoutingModel_DebugOutputAssignment(self, solution_assignment, dimension_to_print)

Print some debugging information about an assignment, including the feasible intervals of the CumulVar for dimension "dimension_to_print" at each step of the routes. If "dimension_to_print" is omitted, all dimensions will be printed.

def solver(self):
5828    def solver(self):
5829        r"""
5830        Returns a vector cumul_bounds, for which cumul_bounds[i][j] is a pair
5831        containing the minimum and maximum of the CumulVar of the jth node on
5832        route i.
5833        - cumul_bounds[i][j].first is the minimum.
5834        - cumul_bounds[i][j].second is the maximum.
5835        Returns the underlying constraint solver. Can be used to add extra
5836        constraints and/or modify search algorithms.
5837        """
5838        return _pywrapcp.RoutingModel_solver(self)

Returns a vector cumul_bounds, for which cumul_bounds[i][j] is a pair containing the minimum and maximum of the CumulVar of the jth node on route i.

  • cumul_bounds[i][j].first is the minimum.
  • cumul_bounds[i][j].second is the maximum. Returns the underlying constraint solver. Can be used to add extra constraints and/or modify search algorithms.
def CheckLimit(self, *args):
5840    def CheckLimit(self, *args):
5841        r"""
5842        Returns true if the search limit has been crossed with the given time
5843        offset.
5844        """
5845        return _pywrapcp.RoutingModel_CheckLimit(self, *args)

Returns true if the search limit has been crossed with the given time offset.

def RemainingTime(self):
5847    def RemainingTime(self):
5848        r""" Returns the time left in the search limit."""
5849        return _pywrapcp.RoutingModel_RemainingTime(self)

Returns the time left in the search limit.

def TimeBuffer(self):
5851    def TimeBuffer(self):
5852        r""" Returns the time buffer to safely return a solution."""
5853        return _pywrapcp.RoutingModel_TimeBuffer(self)

Returns the time buffer to safely return a solution.

def nodes(self):
5855    def nodes(self):
5856        r"""
5857        Sizes and indices
5858        Returns the number of nodes in the model.
5859        """
5860        return _pywrapcp.RoutingModel_nodes(self)

Sizes and indices Returns the number of nodes in the model.

def vehicles(self):
5862    def vehicles(self):
5863        r""" Returns the number of vehicle routes in the model."""
5864        return _pywrapcp.RoutingModel_vehicles(self)

Returns the number of vehicle routes in the model.

def Size(self):
5866    def Size(self):
5867        r""" Returns the number of next variables in the model."""
5868        return _pywrapcp.RoutingModel_Size(self)

Returns the number of next variables in the model.

def GetNumberOfDecisionsInFirstSolution(self, search_parameters):
5870    def GetNumberOfDecisionsInFirstSolution(self, search_parameters):
5871        r"""
5872        Returns statistics on first solution search, number of decisions sent to
5873        filters, number of decisions rejected by filters.
5874        """
5875        return _pywrapcp.RoutingModel_GetNumberOfDecisionsInFirstSolution(self, search_parameters)

Returns statistics on first solution search, number of decisions sent to filters, number of decisions rejected by filters.

def GetNumberOfRejectsInFirstSolution(self, search_parameters):
5877    def GetNumberOfRejectsInFirstSolution(self, search_parameters):
5878        return _pywrapcp.RoutingModel_GetNumberOfRejectsInFirstSolution(self, search_parameters)
def GetAutomaticFirstSolutionStrategy(self):
5880    def GetAutomaticFirstSolutionStrategy(self):
5881        r""" Returns the automatic first solution strategy selected."""
5882        return _pywrapcp.RoutingModel_GetAutomaticFirstSolutionStrategy(self)

Returns the automatic first solution strategy selected.

def IsMatchingModel(self):
5884    def IsMatchingModel(self):
5885        r""" Returns true if a vehicle/node matching problem is detected."""
5886        return _pywrapcp.RoutingModel_IsMatchingModel(self)

Returns true if a vehicle/node matching problem is detected.

def AreRoutesInterdependent(self, parameters):
5888    def AreRoutesInterdependent(self, parameters):
5889        r"""
5890        Returns true if routes are interdependent. This means that any
5891        modification to a route might impact another.
5892        """
5893        return _pywrapcp.RoutingModel_AreRoutesInterdependent(self, parameters)

Returns true if routes are interdependent. This means that any modification to a route might impact another.

def MakeGuidedSlackFinalizer(self, dimension, initializer):
5895    def MakeGuidedSlackFinalizer(self, dimension, initializer):
5896        r"""
5897        The next few members are in the public section only for testing purposes.
5898
5899        MakeGuidedSlackFinalizer creates a DecisionBuilder for the slacks of a
5900        dimension using a callback to choose which values to start with.
5901        The finalizer works only when all next variables in the model have
5902        been fixed. It has the following two characteristics:
5903        1. It follows the routes defined by the nexts variables when choosing a
5904           variable to make a decision on.
5905        2. When it comes to choose a value for the slack of node i, the decision
5906           builder first calls the callback with argument i, and supposingly the
5907           returned value is x it creates decisions slack[i] = x, slack[i] = x +
5908           1, slack[i] = x - 1, slack[i] = x + 2, etc.
5909        """
5910        return _pywrapcp.RoutingModel_MakeGuidedSlackFinalizer(self, dimension, initializer)

The next few members are in the public section only for testing purposes.

MakeGuidedSlackFinalizer creates a DecisionBuilder for the slacks of a dimension using a callback to choose which values to start with. The finalizer works only when all next variables in the model have been fixed. It has the following two characteristics:

  1. It follows the routes defined by the nexts variables when choosing a variable to make a decision on.
  2. When it comes to choose a value for the slack of node i, the decision builder first calls the callback with argument i, and supposingly the returned value is x it creates decisions slack[i] = x, slack[i] = x + 1, slack[i] = x - 1, slack[i] = x + 2, etc.
def MakeSelfDependentDimensionFinalizer(self, dimension):
5912    def MakeSelfDependentDimensionFinalizer(self, dimension):
5913        r"""
5914        MakeSelfDependentDimensionFinalizer is a finalizer for the slacks of a
5915        self-dependent dimension. It makes an extensive use of the caches of the
5916        state dependent transits.
5917        In detail, MakeSelfDependentDimensionFinalizer returns a composition of a
5918        local search decision builder with a greedy descent operator for the cumul
5919        of the start of each route and a guided slack finalizer. Provided there
5920        are no time windows and the maximum slacks are large enough, once the
5921        cumul of the start of route is fixed, the guided finalizer can find
5922        optimal values of the slacks for the rest of the route in time
5923        proportional to the length of the route. Therefore the composed finalizer
5924        generally works in time O(log(t)*n*m), where t is the latest possible
5925        departute time, n is the number of nodes in the network and m is the
5926        number of vehicles.
5927        """
5928        return _pywrapcp.RoutingModel_MakeSelfDependentDimensionFinalizer(self, dimension)

MakeSelfDependentDimensionFinalizer is a finalizer for the slacks of a self-dependent dimension. It makes an extensive use of the caches of the state dependent transits. In detail, MakeSelfDependentDimensionFinalizer returns a composition of a local search decision builder with a greedy descent operator for the cumul of the start of each route and a guided slack finalizer. Provided there are no time windows and the maximum slacks are large enough, once the cumul of the start of route is fixed, the guided finalizer can find optimal values of the slacks for the rest of the route in time proportional to the length of the route. Therefore the composed finalizer generally works in time O(log(t)nm), where t is the latest possible departute time, n is the number of nodes in the network and m is the number of vehicles.

def GetPathsMetadata(self):
5930    def GetPathsMetadata(self):
5931        return _pywrapcp.RoutingModel_GetPathsMetadata(self)
kNoPenalty = -1
kNoDisjunction = <Swig Object of type 'RoutingDisjunctionIndex *'>
kNoDimension = <Swig Object of type 'RoutingDimensionIndex *'>
cvar = <Swig global variables>
class RoutingModelVisitor(BaseObject):
5940class RoutingModelVisitor(BaseObject):
5941    r""" Routing model visitor."""
5942
5943    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5944    __repr__ = _swig_repr
5945
5946    def __init__(self):
5947        _pywrapcp.RoutingModelVisitor_swiginit(self, _pywrapcp.new_RoutingModelVisitor())
5948    __swig_destroy__ = _pywrapcp.delete_RoutingModelVisitor

Routing model visitor.

thisown

The membership flag

kLightElement = 'LightElement'
kLightElement2 = 'LightElement2'
kRemoveValues = 'RemoveValues'
Inherited Members
BaseObject
DebugString
class GlobalVehicleBreaksConstraint(Constraint):
5956class GlobalVehicleBreaksConstraint(Constraint):
5957    r"""
5958    GlobalVehicleBreaksConstraint ensures breaks constraints are enforced on
5959    all vehicles in the dimension passed to its constructor.
5960    It is intended to be used for dimensions representing time.
5961    A break constraint ensures break intervals fit on the route of a vehicle.
5962    For a given vehicle, it forces break intervals to be disjoint from visit
5963    intervals, where visit intervals start at CumulVar(node) and last for
5964    node_visit_transit[node]. Moreover, it ensures that there is enough time
5965    between two consecutive nodes of a route to do transit and vehicle breaks,
5966    i.e. if Next(nodeA) = nodeB, CumulVar(nodeA) = tA and CumulVar(nodeB) = tB,
5967    then SlackVar(nodeA) >= sum_{breaks [tA, tB)} duration(break).
5968    """
5969
5970    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5971    __repr__ = _swig_repr
5972
5973    def __init__(self, dimension):
5974        _pywrapcp.GlobalVehicleBreaksConstraint_swiginit(self, _pywrapcp.new_GlobalVehicleBreaksConstraint(dimension))
5975
5976    def DebugString(self):
5977        return _pywrapcp.GlobalVehicleBreaksConstraint_DebugString(self)
5978
5979    def Post(self):
5980        return _pywrapcp.GlobalVehicleBreaksConstraint_Post(self)
5981
5982    def InitialPropagateWrapper(self):
5983        return _pywrapcp.GlobalVehicleBreaksConstraint_InitialPropagateWrapper(self)
5984    __swig_destroy__ = _pywrapcp.delete_GlobalVehicleBreaksConstraint

GlobalVehicleBreaksConstraint ensures breaks constraints are enforced on all vehicles in the dimension passed to its constructor. It is intended to be used for dimensions representing time. A break constraint ensures break intervals fit on the route of a vehicle. For a given vehicle, it forces break intervals to be disjoint from visit intervals, where visit intervals start at CumulVar(node) and last for node_visit_transit[node]. Moreover, it ensures that there is enough time between two consecutive nodes of a route to do transit and vehicle breaks, i.e. if Next(nodeA) = nodeB, CumulVar(nodeA) = tA and CumulVar(nodeB) = tB, then SlackVar(nodeA) >= sum_{breaks [tA, tB)} duration(break).

GlobalVehicleBreaksConstraint(dimension)
5973    def __init__(self, dimension):
5974        _pywrapcp.GlobalVehicleBreaksConstraint_swiginit(self, _pywrapcp.new_GlobalVehicleBreaksConstraint(dimension))
thisown

The membership flag

def DebugString(self):
5976    def DebugString(self):
5977        return _pywrapcp.GlobalVehicleBreaksConstraint_DebugString(self)
def Post(self):
5979    def Post(self):
5980        return _pywrapcp.GlobalVehicleBreaksConstraint_Post(self)

This method is called when the constraint is processed by the solver. Its main usage is to attach demons to variables.

def InitialPropagateWrapper(self):
5982    def InitialPropagateWrapper(self):
5983        return _pywrapcp.GlobalVehicleBreaksConstraint_InitialPropagateWrapper(self)

This method performs the initial propagation of the constraint. It is called just after the post.

class TypeRegulationsChecker:
5988class TypeRegulationsChecker(object):
5989    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
5990
5991    def __init__(self, *args, **kwargs):
5992        raise AttributeError("No constructor defined - class is abstract")
5993    __repr__ = _swig_repr
5994    __swig_destroy__ = _pywrapcp.delete_TypeRegulationsChecker
5995
5996    def CheckVehicle(self, vehicle, next_accessor):
5997        return _pywrapcp.TypeRegulationsChecker_CheckVehicle(self, vehicle, next_accessor)
TypeRegulationsChecker(*args, **kwargs)
5991    def __init__(self, *args, **kwargs):
5992        raise AttributeError("No constructor defined - class is abstract")
thisown

The membership flag

def CheckVehicle(self, vehicle, next_accessor):
5996    def CheckVehicle(self, vehicle, next_accessor):
5997        return _pywrapcp.TypeRegulationsChecker_CheckVehicle(self, vehicle, next_accessor)
class TypeIncompatibilityChecker(TypeRegulationsChecker):
6001class TypeIncompatibilityChecker(TypeRegulationsChecker):
6002    r""" Checker for type incompatibilities."""
6003
6004    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6005    __repr__ = _swig_repr
6006
6007    def __init__(self, model, check_hard_incompatibilities):
6008        _pywrapcp.TypeIncompatibilityChecker_swiginit(self, _pywrapcp.new_TypeIncompatibilityChecker(model, check_hard_incompatibilities))
6009    __swig_destroy__ = _pywrapcp.delete_TypeIncompatibilityChecker

Checker for type incompatibilities.

TypeIncompatibilityChecker(model, check_hard_incompatibilities)
6007    def __init__(self, model, check_hard_incompatibilities):
6008        _pywrapcp.TypeIncompatibilityChecker_swiginit(self, _pywrapcp.new_TypeIncompatibilityChecker(model, check_hard_incompatibilities))
thisown

The membership flag

class TypeRequirementChecker(TypeRegulationsChecker):
6013class TypeRequirementChecker(TypeRegulationsChecker):
6014    r""" Checker for type requirements."""
6015
6016    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6017    __repr__ = _swig_repr
6018
6019    def __init__(self, model):
6020        _pywrapcp.TypeRequirementChecker_swiginit(self, _pywrapcp.new_TypeRequirementChecker(model))
6021    __swig_destroy__ = _pywrapcp.delete_TypeRequirementChecker

Checker for type requirements.

TypeRequirementChecker(model)
6019    def __init__(self, model):
6020        _pywrapcp.TypeRequirementChecker_swiginit(self, _pywrapcp.new_TypeRequirementChecker(model))
thisown

The membership flag

class TypeRegulationsConstraint(Constraint):
6025class TypeRegulationsConstraint(Constraint):
6026    r"""
6027    The following constraint ensures that incompatibilities and requirements
6028    between types are respected.
6029
6030    It verifies both "hard" and "temporal" incompatibilities.
6031    Two nodes with hard incompatible types cannot be served by the same vehicle
6032    at all, while with a temporal incompatibility they can't be on the same
6033    route at the same time.
6034    The VisitTypePolicy of a node determines how visiting it impacts the type
6035    count on the route.
6036
6037    For example, for
6038    - three temporally incompatible types T1 T2 and T3
6039    - 2 pairs of nodes a1/r1 and a2/r2 of type T1 and T2 respectively, with
6040        - a1 and a2 of VisitTypePolicy TYPE_ADDED_TO_VEHICLE
6041        - r1 and r2 of policy ADDED_TYPE_REMOVED_FROM_VEHICLE
6042    - 3 nodes A, UV and AR of type T3, respectively with type policies
6043      TYPE_ADDED_TO_VEHICLE, TYPE_ON_VEHICLE_UP_TO_VISIT and
6044      TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED
6045    the configurations
6046    UV --> a1 --> r1 --> a2 --> r2,   a1 --> r1 --> a2 --> r2 --> A and
6047    a1 --> r1 --> AR --> a2 --> r2 are acceptable, whereas the configurations
6048    a1 --> a2 --> r1 --> ..., or A --> a1 --> r1 --> ..., or
6049    a1 --> r1 --> UV --> ... are not feasible.
6050
6051    It also verifies same-vehicle and temporal type requirements.
6052    A node of type T_d with a same-vehicle requirement for type T_r needs to be
6053    served by the same vehicle as a node of type T_r.
6054    Temporal requirements, on the other hand, can take effect either when the
6055    dependent type is being added to the route or when it's removed from it,
6056    which is determined by the dependent node's VisitTypePolicy.
6057    In the above example:
6058    - If T3 is required on the same vehicle as T1, A, AR or UV must be on the
6059      same vehicle as a1.
6060    - If T2 is required when adding T1, a2 must be visited *before* a1, and if
6061      r2 is also visited on the route, it must be *after* a1, i.e. T2 must be on
6062      the vehicle when a1 is visited:
6063      ... --> a2 --> ... --> a1 --> ... --> r2 --> ...
6064    - If T3 is required when removing T1, T3 needs to be on the vehicle when
6065      r1 is visited:
6066      ... --> A --> ... --> r1 --> ...   OR   ... --> r1 --> ... --> UV --> ...
6067    """
6068
6069    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6070    __repr__ = _swig_repr
6071
6072    def __init__(self, model):
6073        _pywrapcp.TypeRegulationsConstraint_swiginit(self, _pywrapcp.new_TypeRegulationsConstraint(model))
6074
6075    def Post(self):
6076        return _pywrapcp.TypeRegulationsConstraint_Post(self)
6077
6078    def InitialPropagateWrapper(self):
6079        return _pywrapcp.TypeRegulationsConstraint_InitialPropagateWrapper(self)
6080    __swig_destroy__ = _pywrapcp.delete_TypeRegulationsConstraint

The following constraint ensures that incompatibilities and requirements between types are respected.

It verifies both "hard" and "temporal" incompatibilities. Two nodes with hard incompatible types cannot be served by the same vehicle at all, while with a temporal incompatibility they can't be on the same route at the same time. The VisitTypePolicy of a node determines how visiting it impacts the type count on the route.

For example, for

  • three temporally incompatible types T1 T2 and T3
  • 2 pairs of nodes a1/r1 and a2/r2 of type T1 and T2 respectively, with
    • a1 and a2 of VisitTypePolicy TYPE_ADDED_TO_VEHICLE
    • r1 and r2 of policy ADDED_TYPE_REMOVED_FROM_VEHICLE
  • 3 nodes A, UV and AR of type T3, respectively with type policies TYPE_ADDED_TO_VEHICLE, TYPE_ON_VEHICLE_UP_TO_VISIT and TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED the configurations UV --> a1 --> r1 --> a2 --> r2, a1 --> r1 --> a2 --> r2 --> A and a1 --> r1 --> AR --> a2 --> r2 are acceptable, whereas the configurations a1 --> a2 --> r1 --> ..., or A --> a1 --> r1 --> ..., or a1 --> r1 --> UV --> ... are not feasible.

It also verifies same-vehicle and temporal type requirements. A node of type T_d with a same-vehicle requirement for type T_r needs to be served by the same vehicle as a node of type T_r. Temporal requirements, on the other hand, can take effect either when the dependent type is being added to the route or when it's removed from it, which is determined by the dependent node's VisitTypePolicy. In the above example:

  • If T3 is required on the same vehicle as T1, A, AR or UV must be on the same vehicle as a1.
  • If T2 is required when adding T1, a2 must be visited before a1, and if r2 is also visited on the route, it must be after a1, i.e. T2 must be on the vehicle when a1 is visited: ... --> a2 --> ... --> a1 --> ... --> r2 --> ...
  • If T3 is required when removing T1, T3 needs to be on the vehicle when r1 is visited: ... --> A --> ... --> r1 --> ... OR ... --> r1 --> ... --> UV --> ...
TypeRegulationsConstraint(model)
6072    def __init__(self, model):
6073        _pywrapcp.TypeRegulationsConstraint_swiginit(self, _pywrapcp.new_TypeRegulationsConstraint(model))
thisown

The membership flag

def Post(self):
6075    def Post(self):
6076        return _pywrapcp.TypeRegulationsConstraint_Post(self)

This method is called when the constraint is processed by the solver. Its main usage is to attach demons to variables.

def InitialPropagateWrapper(self):
6078    def InitialPropagateWrapper(self):
6079        return _pywrapcp.TypeRegulationsConstraint_InitialPropagateWrapper(self)

This method performs the initial propagation of the constraint. It is called just after the post.

class BoundCost:
6084class BoundCost(object):
6085    r"""
6086    A structure meant to store soft bounds and associated violation constants.
6087    It is 'Simple' because it has one BoundCost per element,
6088    in contrast to 'Multiple'. Design notes:
6089    - it is meant to store model information to be shared through pointers,
6090      so it disallows copy and assign to avoid accidental duplication.
6091    - it keeps soft bounds as an array of structs to help cache,
6092      because code that uses such bounds typically use both bound and cost.
6093    - soft bounds are named pairs, prevents some mistakes.
6094    - using operator[] to access elements is not interesting,
6095      because the structure will be accessed through pointers, moreover having
6096      to type bound_cost reminds the user of the order if they do a copy
6097      assignment of the element.
6098    """
6099
6100    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6101    __repr__ = _swig_repr
6102    bound = property(_pywrapcp.BoundCost_bound_get, _pywrapcp.BoundCost_bound_set)
6103    cost = property(_pywrapcp.BoundCost_cost_get, _pywrapcp.BoundCost_cost_set)
6104
6105    def __init__(self, *args):
6106        _pywrapcp.BoundCost_swiginit(self, _pywrapcp.new_BoundCost(*args))
6107    __swig_destroy__ = _pywrapcp.delete_BoundCost

A structure meant to store soft bounds and associated violation constants. It is 'Simple' because it has one BoundCost per element, in contrast to 'Multiple'. Design notes:

  • it is meant to store model information to be shared through pointers, so it disallows copy and assign to avoid accidental duplication.
  • it keeps soft bounds as an array of structs to help cache, because code that uses such bounds typically use both bound and cost.
  • soft bounds are named pairs, prevents some mistakes.
  • using operator[] to access elements is not interesting, because the structure will be accessed through pointers, moreover having to type bound_cost reminds the user of the order if they do a copy assignment of the element.
BoundCost(*args)
6105    def __init__(self, *args):
6106        _pywrapcp.BoundCost_swiginit(self, _pywrapcp.new_BoundCost(*args))
thisown

The membership flag

bound
cost
class SimpleBoundCosts:
6111class SimpleBoundCosts(object):
6112    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6113    __repr__ = _swig_repr
6114
6115    def __init__(self, num_bounds, default_bound_cost):
6116        _pywrapcp.SimpleBoundCosts_swiginit(self, _pywrapcp.new_SimpleBoundCosts(num_bounds, default_bound_cost))
6117
6118    def bound_cost(self, element):
6119        return _pywrapcp.SimpleBoundCosts_bound_cost(self, element)
6120
6121    def size(self):
6122        return _pywrapcp.SimpleBoundCosts_size(self)
6123    __swig_destroy__ = _pywrapcp.delete_SimpleBoundCosts
SimpleBoundCosts(num_bounds, default_bound_cost)
6115    def __init__(self, num_bounds, default_bound_cost):
6116        _pywrapcp.SimpleBoundCosts_swiginit(self, _pywrapcp.new_SimpleBoundCosts(num_bounds, default_bound_cost))
thisown

The membership flag

def bound_cost(self, element):
6118    def bound_cost(self, element):
6119        return _pywrapcp.SimpleBoundCosts_bound_cost(self, element)
def size(self):
6121    def size(self):
6122        return _pywrapcp.SimpleBoundCosts_size(self)
class RoutingDimension:
6127class RoutingDimension(object):
6128    r"""
6129    Dimensions represent quantities accumulated at nodes along the routes. They
6130    represent quantities such as weights or volumes carried along the route, or
6131    distance or times.
6132
6133    Quantities at a node are represented by "cumul" variables and the increase
6134    or decrease of quantities between nodes are represented by "transit"
6135    variables. These variables are linked as follows:
6136
6137    if j == next(i),
6138    cumuls(j) = cumuls(i) + transits(i) + slacks(i) +
6139                state_dependent_transits(i)
6140
6141    where slack is a positive slack variable (can represent waiting times for
6142    a time dimension), and state_dependent_transits is a non-purely functional
6143    version of transits_. Favour transits over state_dependent_transits when
6144    possible, because purely functional callbacks allow more optimisations and
6145    make the model faster and easier to solve.
6146    for a given vehicle, it is passed as an external vector, it would be better
6147    to have this information here.
6148    """
6149
6150    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
6151
6152    def __init__(self, *args, **kwargs):
6153        raise AttributeError("No constructor defined")
6154    __repr__ = _swig_repr
6155    __swig_destroy__ = _pywrapcp.delete_RoutingDimension
6156
6157    def model(self):
6158        r""" Returns the model on which the dimension was created."""
6159        return _pywrapcp.RoutingDimension_model(self)
6160
6161    def GetTransitValue(self, from_index, to_index, vehicle):
6162        r"""
6163        Returns the transition value for a given pair of nodes (as var index);
6164        this value is the one taken by the corresponding transit variable when
6165        the 'next' variable for 'from_index' is bound to 'to_index'.
6166        """
6167        return _pywrapcp.RoutingDimension_GetTransitValue(self, from_index, to_index, vehicle)
6168
6169    def GetTransitValueFromClass(self, from_index, to_index, vehicle_class):
6170        r"""
6171        Same as above but taking a vehicle class of the dimension instead of a
6172        vehicle (the class of a vehicle can be obtained with vehicle_to_class()).
6173        """
6174        return _pywrapcp.RoutingDimension_GetTransitValueFromClass(self, from_index, to_index, vehicle_class)
6175
6176    def CumulVar(self, index):
6177        r"""
6178        Get the cumul, transit and slack variables for the given node (given as
6179        int64_t var index).
6180        """
6181        return _pywrapcp.RoutingDimension_CumulVar(self, index)
6182
6183    def TransitVar(self, index):
6184        return _pywrapcp.RoutingDimension_TransitVar(self, index)
6185
6186    def FixedTransitVar(self, index):
6187        return _pywrapcp.RoutingDimension_FixedTransitVar(self, index)
6188
6189    def SlackVar(self, index):
6190        return _pywrapcp.RoutingDimension_SlackVar(self, index)
6191
6192    def SetSpanUpperBoundForVehicle(self, upper_bound, vehicle):
6193        r"""
6194        Sets an upper bound on the dimension span on a given vehicle. This is the
6195        preferred way to limit the "length" of the route of a vehicle according to
6196        a dimension.
6197        """
6198        return _pywrapcp.RoutingDimension_SetSpanUpperBoundForVehicle(self, upper_bound, vehicle)
6199
6200    def SetSpanCostCoefficientForVehicle(self, coefficient, vehicle):
6201        r"""
6202        Sets a cost proportional to the dimension span on a given vehicle,
6203        or on all vehicles at once. "coefficient" must be nonnegative.
6204        This is handy to model costs proportional to idle time when the dimension
6205        represents time.
6206        The cost for a vehicle is
6207          span_cost = coefficient * (dimension end value - dimension start value).
6208        """
6209        return _pywrapcp.RoutingDimension_SetSpanCostCoefficientForVehicle(self, coefficient, vehicle)
6210
6211    def SetSpanCostCoefficientForAllVehicles(self, coefficient):
6212        return _pywrapcp.RoutingDimension_SetSpanCostCoefficientForAllVehicles(self, coefficient)
6213
6214    def SetGlobalSpanCostCoefficient(self, coefficient):
6215        r"""
6216        Sets a cost proportional to the *global* dimension span, that is the
6217        difference between the largest value of route end cumul variables and
6218        the smallest value of route start cumul variables.
6219        In other words:
6220        global_span_cost =
6221          coefficient * (Max(dimension end value) - Min(dimension start value)).
6222        """
6223        return _pywrapcp.RoutingDimension_SetGlobalSpanCostCoefficient(self, coefficient)
6224
6225    def SetCumulVarSoftUpperBound(self, index, upper_bound, coefficient):
6226        r"""
6227        Sets a soft upper bound to the cumul variable of a given variable index.
6228        If the value of the cumul variable is greater than the bound, a cost
6229        proportional to the difference between this value and the bound is added
6230        to the cost function of the model:
6231          cumulVar <= upper_bound -> cost = 0
6232           cumulVar > upper_bound -> cost = coefficient * (cumulVar - upper_bound)
6233        This is also handy to model tardiness costs when the dimension represents
6234        time.
6235        """
6236        return _pywrapcp.RoutingDimension_SetCumulVarSoftUpperBound(self, index, upper_bound, coefficient)
6237
6238    def HasCumulVarSoftUpperBound(self, index):
6239        r"""
6240        Returns true if a soft upper bound has been set for a given variable
6241        index.
6242        """
6243        return _pywrapcp.RoutingDimension_HasCumulVarSoftUpperBound(self, index)
6244
6245    def GetCumulVarSoftUpperBound(self, index):
6246        r"""
6247        Returns the soft upper bound of a cumul variable for a given variable
6248        index. The "hard" upper bound of the variable is returned if no soft upper
6249        bound has been set.
6250        """
6251        return _pywrapcp.RoutingDimension_GetCumulVarSoftUpperBound(self, index)
6252
6253    def GetCumulVarSoftUpperBoundCoefficient(self, index):
6254        r"""
6255        Returns the cost coefficient of the soft upper bound of a cumul variable
6256        for a given variable index. If no soft upper bound has been set, 0 is
6257        returned.
6258        """
6259        return _pywrapcp.RoutingDimension_GetCumulVarSoftUpperBoundCoefficient(self, index)
6260
6261    def SetCumulVarSoftLowerBound(self, index, lower_bound, coefficient):
6262        r"""
6263        Sets a soft lower bound to the cumul variable of a given variable index.
6264        If the value of the cumul variable is less than the bound, a cost
6265        proportional to the difference between this value and the bound is added
6266        to the cost function of the model:
6267          cumulVar > lower_bound -> cost = 0
6268          cumulVar <= lower_bound -> cost = coefficient * (lower_bound -
6269                      cumulVar).
6270        This is also handy to model earliness costs when the dimension represents
6271        time.
6272        """
6273        return _pywrapcp.RoutingDimension_SetCumulVarSoftLowerBound(self, index, lower_bound, coefficient)
6274
6275    def HasCumulVarSoftLowerBound(self, index):
6276        r"""
6277        Returns true if a soft lower bound has been set for a given variable
6278        index.
6279        """
6280        return _pywrapcp.RoutingDimension_HasCumulVarSoftLowerBound(self, index)
6281
6282    def GetCumulVarSoftLowerBound(self, index):
6283        r"""
6284        Returns the soft lower bound of a cumul variable for a given variable
6285        index. The "hard" lower bound of the variable is returned if no soft lower
6286        bound has been set.
6287        """
6288        return _pywrapcp.RoutingDimension_GetCumulVarSoftLowerBound(self, index)
6289
6290    def GetCumulVarSoftLowerBoundCoefficient(self, index):
6291        r"""
6292        Returns the cost coefficient of the soft lower bound of a cumul variable
6293        for a given variable index. If no soft lower bound has been set, 0 is
6294        returned.
6295        """
6296        return _pywrapcp.RoutingDimension_GetCumulVarSoftLowerBoundCoefficient(self, index)
6297
6298    def SetBreakIntervalsOfVehicle(self, breaks, vehicle, node_visit_transits):
6299        r"""
6300        Sets the breaks for a given vehicle. Breaks are represented by
6301        IntervalVars. They may interrupt transits between nodes and increase
6302        the value of corresponding slack variables.
6303        A break may take place before the start of a vehicle, after the end of
6304        a vehicle, or during a travel i -> j.
6305
6306        In that case, the interval [break.Start(), break.End()) must be a subset
6307        of [CumulVar(i) + pre_travel(i, j), CumulVar(j) - post_travel(i, j)). In
6308        other words, a break may not overlap any node n's visit, given by
6309        [CumulVar(n) - post_travel(_, n), CumulVar(n) + pre_travel(n, _)).
6310        This formula considers post_travel(_, start) and pre_travel(end, _) to be
6311        0; pre_travel will never be called on any (_, start) and post_travel will
6312        never we called on any (end, _). If pre_travel_evaluator or
6313        post_travel_evaluator is -1, it will be taken as a function that always
6314        returns 0.
6315        Deprecated, sets pre_travel(i, j) = node_visit_transit[i].
6316        """
6317        return _pywrapcp.RoutingDimension_SetBreakIntervalsOfVehicle(self, breaks, vehicle, node_visit_transits)
6318
6319    def SetBreakDistanceDurationOfVehicle(self, distance, duration, vehicle):
6320        r"""
6321        With breaks supposed to be consecutive, this forces the distance between
6322        breaks of size at least minimum_break_duration to be at most distance.
6323        This supposes that the time until route start and after route end are
6324        infinite breaks.
6325        """
6326        return _pywrapcp.RoutingDimension_SetBreakDistanceDurationOfVehicle(self, distance, duration, vehicle)
6327
6328    def InitializeBreaks(self):
6329        r"""
6330        Sets up vehicle_break_intervals_, vehicle_break_distance_duration_,
6331        pre_travel_evaluators and post_travel_evaluators.
6332        """
6333        return _pywrapcp.RoutingDimension_InitializeBreaks(self)
6334
6335    def HasBreakConstraints(self):
6336        r""" Returns true if any break interval or break distance was defined."""
6337        return _pywrapcp.RoutingDimension_HasBreakConstraints(self)
6338
6339    def GetPreTravelEvaluatorOfVehicle(self, vehicle):
6340        return _pywrapcp.RoutingDimension_GetPreTravelEvaluatorOfVehicle(self, vehicle)
6341
6342    def GetPostTravelEvaluatorOfVehicle(self, vehicle):
6343        return _pywrapcp.RoutingDimension_GetPostTravelEvaluatorOfVehicle(self, vehicle)
6344
6345    def base_dimension(self):
6346        r""" Returns the parent in the dependency tree if any or nullptr otherwise."""
6347        return _pywrapcp.RoutingDimension_base_dimension(self)
6348
6349    def ShortestTransitionSlack(self, node):
6350        r"""
6351        It makes sense to use the function only for self-dependent dimension.
6352        For such dimensions the value of the slack of a node determines the
6353        transition cost of the next transit. Provided that
6354          1. cumul[node] is fixed,
6355          2. next[node] and next[next[node]] (if exists) are fixed,
6356        the value of slack[node] for which cumul[next[node]] + transit[next[node]]
6357        is minimized can be found in O(1) using this function.
6358        """
6359        return _pywrapcp.RoutingDimension_ShortestTransitionSlack(self, node)
6360
6361    def name(self):
6362        r""" Returns the name of the dimension."""
6363        return _pywrapcp.RoutingDimension_name(self)
6364
6365    def SetPickupToDeliveryLimitFunctionForPair(self, limit_function, pair_index):
6366        return _pywrapcp.RoutingDimension_SetPickupToDeliveryLimitFunctionForPair(self, limit_function, pair_index)
6367
6368    def HasPickupToDeliveryLimits(self):
6369        return _pywrapcp.RoutingDimension_HasPickupToDeliveryLimits(self)
6370
6371    def AddNodePrecedence(self, first_node, second_node, offset):
6372        return _pywrapcp.RoutingDimension_AddNodePrecedence(self, first_node, second_node, offset)
6373
6374    def GetSpanUpperBoundForVehicle(self, vehicle):
6375        return _pywrapcp.RoutingDimension_GetSpanUpperBoundForVehicle(self, vehicle)
6376
6377    def GetSpanCostCoefficientForVehicle(self, vehicle):
6378        return _pywrapcp.RoutingDimension_GetSpanCostCoefficientForVehicle(self, vehicle)
6379
6380    def global_span_cost_coefficient(self):
6381        return _pywrapcp.RoutingDimension_global_span_cost_coefficient(self)
6382
6383    def GetGlobalOptimizerOffset(self):
6384        return _pywrapcp.RoutingDimension_GetGlobalOptimizerOffset(self)
6385
6386    def GetLocalOptimizerOffsetForVehicle(self, vehicle):
6387        return _pywrapcp.RoutingDimension_GetLocalOptimizerOffsetForVehicle(self, vehicle)
6388
6389    def SetSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle):
6390        r"""
6391        If the span of vehicle on this dimension is larger than bound,
6392        the cost will be increased by cost * (span - bound).
6393        """
6394        return _pywrapcp.RoutingDimension_SetSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle)
6395
6396    def HasSoftSpanUpperBounds(self):
6397        return _pywrapcp.RoutingDimension_HasSoftSpanUpperBounds(self)
6398
6399    def GetSoftSpanUpperBoundForVehicle(self, vehicle):
6400        return _pywrapcp.RoutingDimension_GetSoftSpanUpperBoundForVehicle(self, vehicle)
6401
6402    def SetQuadraticCostSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle):
6403        r"""
6404        If the span of vehicle on this dimension is larger than bound,
6405        the cost will be increased by cost * (span - bound)^2.
6406        """
6407        return _pywrapcp.RoutingDimension_SetQuadraticCostSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle)
6408
6409    def HasQuadraticCostSoftSpanUpperBounds(self):
6410        return _pywrapcp.RoutingDimension_HasQuadraticCostSoftSpanUpperBounds(self)
6411
6412    def GetQuadraticCostSoftSpanUpperBoundForVehicle(self, vehicle):
6413        return _pywrapcp.RoutingDimension_GetQuadraticCostSoftSpanUpperBoundForVehicle(self, vehicle)

Dimensions represent quantities accumulated at nodes along the routes. They represent quantities such as weights or volumes carried along the route, or distance or times.

Quantities at a node are represented by "cumul" variables and the increase or decrease of quantities between nodes are represented by "transit" variables. These variables are linked as follows:

if j == next(i), cumuls(j) = cumuls(i) + transits(i) + slacks(i) + state_dependent_transits(i)

where slack is a positive slack variable (can represent waiting times for a time dimension), and state_dependent_transits is a non-purely functional version of transits_. Favour transits over state_dependent_transits when possible, because purely functional callbacks allow more optimisations and make the model faster and easier to solve. for a given vehicle, it is passed as an external vector, it would be better to have this information here.

RoutingDimension(*args, **kwargs)
6152    def __init__(self, *args, **kwargs):
6153        raise AttributeError("No constructor defined")
thisown

The membership flag

def model(self):
6157    def model(self):
6158        r""" Returns the model on which the dimension was created."""
6159        return _pywrapcp.RoutingDimension_model(self)

Returns the model on which the dimension was created.

def GetTransitValue(self, from_index, to_index, vehicle):
6161    def GetTransitValue(self, from_index, to_index, vehicle):
6162        r"""
6163        Returns the transition value for a given pair of nodes (as var index);
6164        this value is the one taken by the corresponding transit variable when
6165        the 'next' variable for 'from_index' is bound to 'to_index'.
6166        """
6167        return _pywrapcp.RoutingDimension_GetTransitValue(self, from_index, to_index, vehicle)

Returns the transition value for a given pair of nodes (as var index); this value is the one taken by the corresponding transit variable when the 'next' variable for 'from_index' is bound to 'to_index'.

def GetTransitValueFromClass(self, from_index, to_index, vehicle_class):
6169    def GetTransitValueFromClass(self, from_index, to_index, vehicle_class):
6170        r"""
6171        Same as above but taking a vehicle class of the dimension instead of a
6172        vehicle (the class of a vehicle can be obtained with vehicle_to_class()).
6173        """
6174        return _pywrapcp.RoutingDimension_GetTransitValueFromClass(self, from_index, to_index, vehicle_class)

Same as above but taking a vehicle class of the dimension instead of a vehicle (the class of a vehicle can be obtained with vehicle_to_class()).

def CumulVar(self, index):
6176    def CumulVar(self, index):
6177        r"""
6178        Get the cumul, transit and slack variables for the given node (given as
6179        int64_t var index).
6180        """
6181        return _pywrapcp.RoutingDimension_CumulVar(self, index)

Get the cumul, transit and slack variables for the given node (given as int64_t var index).

def TransitVar(self, index):
6183    def TransitVar(self, index):
6184        return _pywrapcp.RoutingDimension_TransitVar(self, index)
def FixedTransitVar(self, index):
6186    def FixedTransitVar(self, index):
6187        return _pywrapcp.RoutingDimension_FixedTransitVar(self, index)
def SlackVar(self, index):
6189    def SlackVar(self, index):
6190        return _pywrapcp.RoutingDimension_SlackVar(self, index)
def SetSpanUpperBoundForVehicle(self, upper_bound, vehicle):
6192    def SetSpanUpperBoundForVehicle(self, upper_bound, vehicle):
6193        r"""
6194        Sets an upper bound on the dimension span on a given vehicle. This is the
6195        preferred way to limit the "length" of the route of a vehicle according to
6196        a dimension.
6197        """
6198        return _pywrapcp.RoutingDimension_SetSpanUpperBoundForVehicle(self, upper_bound, vehicle)

Sets an upper bound on the dimension span on a given vehicle. This is the preferred way to limit the "length" of the route of a vehicle according to a dimension.

def SetSpanCostCoefficientForVehicle(self, coefficient, vehicle):
6200    def SetSpanCostCoefficientForVehicle(self, coefficient, vehicle):
6201        r"""
6202        Sets a cost proportional to the dimension span on a given vehicle,
6203        or on all vehicles at once. "coefficient" must be nonnegative.
6204        This is handy to model costs proportional to idle time when the dimension
6205        represents time.
6206        The cost for a vehicle is
6207          span_cost = coefficient * (dimension end value - dimension start value).
6208        """
6209        return _pywrapcp.RoutingDimension_SetSpanCostCoefficientForVehicle(self, coefficient, vehicle)

Sets a cost proportional to the dimension span on a given vehicle, or on all vehicles at once. "coefficient" must be nonnegative. This is handy to model costs proportional to idle time when the dimension represents time. The cost for a vehicle is span_cost = coefficient * (dimension end value - dimension start value).

def SetSpanCostCoefficientForAllVehicles(self, coefficient):
6211    def SetSpanCostCoefficientForAllVehicles(self, coefficient):
6212        return _pywrapcp.RoutingDimension_SetSpanCostCoefficientForAllVehicles(self, coefficient)
def SetGlobalSpanCostCoefficient(self, coefficient):
6214    def SetGlobalSpanCostCoefficient(self, coefficient):
6215        r"""
6216        Sets a cost proportional to the *global* dimension span, that is the
6217        difference between the largest value of route end cumul variables and
6218        the smallest value of route start cumul variables.
6219        In other words:
6220        global_span_cost =
6221          coefficient * (Max(dimension end value) - Min(dimension start value)).
6222        """
6223        return _pywrapcp.RoutingDimension_SetGlobalSpanCostCoefficient(self, coefficient)

Sets a cost proportional to the global dimension span, that is the difference between the largest value of route end cumul variables and the smallest value of route start cumul variables. In other words: global_span_cost = coefficient * (Max(dimension end value) - Min(dimension start value)).

def SetCumulVarSoftUpperBound(self, index, upper_bound, coefficient):
6225    def SetCumulVarSoftUpperBound(self, index, upper_bound, coefficient):
6226        r"""
6227        Sets a soft upper bound to the cumul variable of a given variable index.
6228        If the value of the cumul variable is greater than the bound, a cost
6229        proportional to the difference between this value and the bound is added
6230        to the cost function of the model:
6231          cumulVar <= upper_bound -> cost = 0
6232           cumulVar > upper_bound -> cost = coefficient * (cumulVar - upper_bound)
6233        This is also handy to model tardiness costs when the dimension represents
6234        time.
6235        """
6236        return _pywrapcp.RoutingDimension_SetCumulVarSoftUpperBound(self, index, upper_bound, coefficient)

Sets a soft upper bound to the cumul variable of a given variable index. If the value of the cumul variable is greater than the bound, a cost proportional to the difference between this value and the bound is added to the cost function of the model: cumulVar <= upper_bound -> cost = 0 cumulVar > upper_bound -> cost = coefficient * (cumulVar - upper_bound) This is also handy to model tardiness costs when the dimension represents time.

def HasCumulVarSoftUpperBound(self, index):
6238    def HasCumulVarSoftUpperBound(self, index):
6239        r"""
6240        Returns true if a soft upper bound has been set for a given variable
6241        index.
6242        """
6243        return _pywrapcp.RoutingDimension_HasCumulVarSoftUpperBound(self, index)

Returns true if a soft upper bound has been set for a given variable index.

def GetCumulVarSoftUpperBound(self, index):
6245    def GetCumulVarSoftUpperBound(self, index):
6246        r"""
6247        Returns the soft upper bound of a cumul variable for a given variable
6248        index. The "hard" upper bound of the variable is returned if no soft upper
6249        bound has been set.
6250        """
6251        return _pywrapcp.RoutingDimension_GetCumulVarSoftUpperBound(self, index)

Returns the soft upper bound of a cumul variable for a given variable index. The "hard" upper bound of the variable is returned if no soft upper bound has been set.

def GetCumulVarSoftUpperBoundCoefficient(self, index):
6253    def GetCumulVarSoftUpperBoundCoefficient(self, index):
6254        r"""
6255        Returns the cost coefficient of the soft upper bound of a cumul variable
6256        for a given variable index. If no soft upper bound has been set, 0 is
6257        returned.
6258        """
6259        return _pywrapcp.RoutingDimension_GetCumulVarSoftUpperBoundCoefficient(self, index)

Returns the cost coefficient of the soft upper bound of a cumul variable for a given variable index. If no soft upper bound has been set, 0 is returned.

def SetCumulVarSoftLowerBound(self, index, lower_bound, coefficient):
6261    def SetCumulVarSoftLowerBound(self, index, lower_bound, coefficient):
6262        r"""
6263        Sets a soft lower bound to the cumul variable of a given variable index.
6264        If the value of the cumul variable is less than the bound, a cost
6265        proportional to the difference between this value and the bound is added
6266        to the cost function of the model:
6267          cumulVar > lower_bound -> cost = 0
6268          cumulVar <= lower_bound -> cost = coefficient * (lower_bound -
6269                      cumulVar).
6270        This is also handy to model earliness costs when the dimension represents
6271        time.
6272        """
6273        return _pywrapcp.RoutingDimension_SetCumulVarSoftLowerBound(self, index, lower_bound, coefficient)

Sets a soft lower bound to the cumul variable of a given variable index. If the value of the cumul variable is less than the bound, a cost proportional to the difference between this value and the bound is added to the cost function of the model: cumulVar > lower_bound -> cost = 0 cumulVar <= lower_bound -> cost = coefficient * (lower_bound - cumulVar). This is also handy to model earliness costs when the dimension represents time.

def HasCumulVarSoftLowerBound(self, index):
6275    def HasCumulVarSoftLowerBound(self, index):
6276        r"""
6277        Returns true if a soft lower bound has been set for a given variable
6278        index.
6279        """
6280        return _pywrapcp.RoutingDimension_HasCumulVarSoftLowerBound(self, index)

Returns true if a soft lower bound has been set for a given variable index.

def GetCumulVarSoftLowerBound(self, index):
6282    def GetCumulVarSoftLowerBound(self, index):
6283        r"""
6284        Returns the soft lower bound of a cumul variable for a given variable
6285        index. The "hard" lower bound of the variable is returned if no soft lower
6286        bound has been set.
6287        """
6288        return _pywrapcp.RoutingDimension_GetCumulVarSoftLowerBound(self, index)

Returns the soft lower bound of a cumul variable for a given variable index. The "hard" lower bound of the variable is returned if no soft lower bound has been set.

def GetCumulVarSoftLowerBoundCoefficient(self, index):
6290    def GetCumulVarSoftLowerBoundCoefficient(self, index):
6291        r"""
6292        Returns the cost coefficient of the soft lower bound of a cumul variable
6293        for a given variable index. If no soft lower bound has been set, 0 is
6294        returned.
6295        """
6296        return _pywrapcp.RoutingDimension_GetCumulVarSoftLowerBoundCoefficient(self, index)

Returns the cost coefficient of the soft lower bound of a cumul variable for a given variable index. If no soft lower bound has been set, 0 is returned.

def SetBreakIntervalsOfVehicle(self, breaks, vehicle, node_visit_transits):
6298    def SetBreakIntervalsOfVehicle(self, breaks, vehicle, node_visit_transits):
6299        r"""
6300        Sets the breaks for a given vehicle. Breaks are represented by
6301        IntervalVars. They may interrupt transits between nodes and increase
6302        the value of corresponding slack variables.
6303        A break may take place before the start of a vehicle, after the end of
6304        a vehicle, or during a travel i -> j.
6305
6306        In that case, the interval [break.Start(), break.End()) must be a subset
6307        of [CumulVar(i) + pre_travel(i, j), CumulVar(j) - post_travel(i, j)). In
6308        other words, a break may not overlap any node n's visit, given by
6309        [CumulVar(n) - post_travel(_, n), CumulVar(n) + pre_travel(n, _)).
6310        This formula considers post_travel(_, start) and pre_travel(end, _) to be
6311        0; pre_travel will never be called on any (_, start) and post_travel will
6312        never we called on any (end, _). If pre_travel_evaluator or
6313        post_travel_evaluator is -1, it will be taken as a function that always
6314        returns 0.
6315        Deprecated, sets pre_travel(i, j) = node_visit_transit[i].
6316        """
6317        return _pywrapcp.RoutingDimension_SetBreakIntervalsOfVehicle(self, breaks, vehicle, node_visit_transits)

Sets the breaks for a given vehicle. Breaks are represented by IntervalVars. They may interrupt transits between nodes and increase the value of corresponding slack variables. A break may take place before the start of a vehicle, after the end of a vehicle, or during a travel i -> j.

In that case, the interval [break.Start(), break.End()) must be a subset of [CumulVar(i) + pre_travel(i, j), CumulVar(j) - post_travel(i, j)). In other words, a break may not overlap any node n's visit, given by [CumulVar(n) - post_travel(_, n), CumulVar(n) + pre_travel(n, _)). This formula considers post_travel(_, start) and pre_travel(end, _) to be 0; pre_travel will never be called on any (_, start) and post_travel will never we called on any (end, _). If pre_travel_evaluator or post_travel_evaluator is -1, it will be taken as a function that always returns 0. Deprecated, sets pre_travel(i, j) = node_visit_transit[i].

def SetBreakDistanceDurationOfVehicle(self, distance, duration, vehicle):
6319    def SetBreakDistanceDurationOfVehicle(self, distance, duration, vehicle):
6320        r"""
6321        With breaks supposed to be consecutive, this forces the distance between
6322        breaks of size at least minimum_break_duration to be at most distance.
6323        This supposes that the time until route start and after route end are
6324        infinite breaks.
6325        """
6326        return _pywrapcp.RoutingDimension_SetBreakDistanceDurationOfVehicle(self, distance, duration, vehicle)

With breaks supposed to be consecutive, this forces the distance between breaks of size at least minimum_break_duration to be at most distance. This supposes that the time until route start and after route end are infinite breaks.

def InitializeBreaks(self):
6328    def InitializeBreaks(self):
6329        r"""
6330        Sets up vehicle_break_intervals_, vehicle_break_distance_duration_,
6331        pre_travel_evaluators and post_travel_evaluators.
6332        """
6333        return _pywrapcp.RoutingDimension_InitializeBreaks(self)

Sets up vehicle_break_intervals_, vehicle_break_distance_duration_, pre_travel_evaluators and post_travel_evaluators.

def HasBreakConstraints(self):
6335    def HasBreakConstraints(self):
6336        r""" Returns true if any break interval or break distance was defined."""
6337        return _pywrapcp.RoutingDimension_HasBreakConstraints(self)

Returns true if any break interval or break distance was defined.

def GetPreTravelEvaluatorOfVehicle(self, vehicle):
6339    def GetPreTravelEvaluatorOfVehicle(self, vehicle):
6340        return _pywrapcp.RoutingDimension_GetPreTravelEvaluatorOfVehicle(self, vehicle)
def GetPostTravelEvaluatorOfVehicle(self, vehicle):
6342    def GetPostTravelEvaluatorOfVehicle(self, vehicle):
6343        return _pywrapcp.RoutingDimension_GetPostTravelEvaluatorOfVehicle(self, vehicle)
def base_dimension(self):
6345    def base_dimension(self):
6346        r""" Returns the parent in the dependency tree if any or nullptr otherwise."""
6347        return _pywrapcp.RoutingDimension_base_dimension(self)

Returns the parent in the dependency tree if any or nullptr otherwise.

def ShortestTransitionSlack(self, node):
6349    def ShortestTransitionSlack(self, node):
6350        r"""
6351        It makes sense to use the function only for self-dependent dimension.
6352        For such dimensions the value of the slack of a node determines the
6353        transition cost of the next transit. Provided that
6354          1. cumul[node] is fixed,
6355          2. next[node] and next[next[node]] (if exists) are fixed,
6356        the value of slack[node] for which cumul[next[node]] + transit[next[node]]
6357        is minimized can be found in O(1) using this function.
6358        """
6359        return _pywrapcp.RoutingDimension_ShortestTransitionSlack(self, node)

It makes sense to use the function only for self-dependent dimension. For such dimensions the value of the slack of a node determines the transition cost of the next transit. Provided that

  1. cumul[node] is fixed,
  2. next[node] and next[next[node]] (if exists) are fixed, the value of slack[node] for which cumul[next[node]] + transit[next[node]] is minimized can be found in O(1) using this function.
def name(self):
6361    def name(self):
6362        r""" Returns the name of the dimension."""
6363        return _pywrapcp.RoutingDimension_name(self)

Returns the name of the dimension.

def SetPickupToDeliveryLimitFunctionForPair(self, limit_function, pair_index):
6365    def SetPickupToDeliveryLimitFunctionForPair(self, limit_function, pair_index):
6366        return _pywrapcp.RoutingDimension_SetPickupToDeliveryLimitFunctionForPair(self, limit_function, pair_index)
def HasPickupToDeliveryLimits(self):
6368    def HasPickupToDeliveryLimits(self):
6369        return _pywrapcp.RoutingDimension_HasPickupToDeliveryLimits(self)
def AddNodePrecedence(self, first_node, second_node, offset):
6371    def AddNodePrecedence(self, first_node, second_node, offset):
6372        return _pywrapcp.RoutingDimension_AddNodePrecedence(self, first_node, second_node, offset)
def GetSpanUpperBoundForVehicle(self, vehicle):
6374    def GetSpanUpperBoundForVehicle(self, vehicle):
6375        return _pywrapcp.RoutingDimension_GetSpanUpperBoundForVehicle(self, vehicle)
def GetSpanCostCoefficientForVehicle(self, vehicle):
6377    def GetSpanCostCoefficientForVehicle(self, vehicle):
6378        return _pywrapcp.RoutingDimension_GetSpanCostCoefficientForVehicle(self, vehicle)
def global_span_cost_coefficient(self):
6380    def global_span_cost_coefficient(self):
6381        return _pywrapcp.RoutingDimension_global_span_cost_coefficient(self)
def GetGlobalOptimizerOffset(self):
6383    def GetGlobalOptimizerOffset(self):
6384        return _pywrapcp.RoutingDimension_GetGlobalOptimizerOffset(self)
def GetLocalOptimizerOffsetForVehicle(self, vehicle):
6386    def GetLocalOptimizerOffsetForVehicle(self, vehicle):
6387        return _pywrapcp.RoutingDimension_GetLocalOptimizerOffsetForVehicle(self, vehicle)
def SetSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle):
6389    def SetSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle):
6390        r"""
6391        If the span of vehicle on this dimension is larger than bound,
6392        the cost will be increased by cost * (span - bound).
6393        """
6394        return _pywrapcp.RoutingDimension_SetSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle)

If the span of vehicle on this dimension is larger than bound, the cost will be increased by cost * (span - bound).

def HasSoftSpanUpperBounds(self):
6396    def HasSoftSpanUpperBounds(self):
6397        return _pywrapcp.RoutingDimension_HasSoftSpanUpperBounds(self)
def GetSoftSpanUpperBoundForVehicle(self, vehicle):
6399    def GetSoftSpanUpperBoundForVehicle(self, vehicle):
6400        return _pywrapcp.RoutingDimension_GetSoftSpanUpperBoundForVehicle(self, vehicle)
def SetQuadraticCostSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle):
6402    def SetQuadraticCostSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle):
6403        r"""
6404        If the span of vehicle on this dimension is larger than bound,
6405        the cost will be increased by cost * (span - bound)^2.
6406        """
6407        return _pywrapcp.RoutingDimension_SetQuadraticCostSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle)

If the span of vehicle on this dimension is larger than bound, the cost will be increased by cost * (span - bound)^2.

def HasQuadraticCostSoftSpanUpperBounds(self):
6409    def HasQuadraticCostSoftSpanUpperBounds(self):
6410        return _pywrapcp.RoutingDimension_HasQuadraticCostSoftSpanUpperBounds(self)
def GetQuadraticCostSoftSpanUpperBoundForVehicle(self, vehicle):
6412    def GetQuadraticCostSoftSpanUpperBoundForVehicle(self, vehicle):
6413        return _pywrapcp.RoutingDimension_GetQuadraticCostSoftSpanUpperBoundForVehicle(self, vehicle)
def SolveModelWithSat(model, search_parameters, initial_solution, solution):
6418def SolveModelWithSat(model, search_parameters, initial_solution, solution):
6419    r"""
6420    Attempts to solve the model using the cp-sat solver. As of 5/2019, will
6421    solve the TSP corresponding to the model if it has a single vehicle.
6422    Therefore the resulting solution might not actually be feasible. Will return
6423    false if a solution could not be found.
6424    """
6425    return _pywrapcp.SolveModelWithSat(model, search_parameters, initial_solution, solution)

Attempts to solve the model using the cp-sat solver. As of 5/2019, will solve the TSP corresponding to the model if it has a single vehicle. Therefore the resulting solution might not actually be feasible. Will return false if a solution could not be found.